/*

* 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 "TXTRICH.H"

#include "TXTINDEX.H"

#include "TXTSTD.H"

#include "TXTRTPFL.H"

#include "ParseLst.h"

#include "TXTCLIPBOARD.H"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "TXTRICHTraces.h"

#endif

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "TXTETEXT_INTERNAL.H"

#include "TXTRICH_INTERNAL.H"

#endif

EXPORT_C void CRichText::__DbgTestInvariant()const

// Provides class invariants.  Explanations below:

//

	{

#ifdef _DEBUG

// ASSERT: The global format layers are never null.

	if (iGlobalParaFormatLayer == NULL)

	    {

	    OstTrace0( TRACE_DUMP, CRICHTEXT_DBGTESTINVARIANT, "Invariant" );

	    }

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

	if (iGlobalCharFormatLayer == NULL)

	    {

	    OstTrace0( TRACE_DUMP, DUP1_CRICHTEXT_DBGTESTINVARIANT, "Invariant" );

	    }

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

	if (IndexPresent())

		{

// ASSERT: The sum of para lengths == the length as described by the document storage.

		TInt cumulativeParaLength = 0;

		TInt maxPara = iIndex->iParaIx->Count();

		for (TInt offset = 0; offset < maxPara; offset++)

			{

			TParaAttribsEntry entry = (*iIndex->iParaIx)[offset];

			cumulativeParaLength += entry.iLength;

			}

		if (cumulativeParaLength != (DocumentLength() + 1))

		    {

		    OstTrace0( TRACE_DUMP, DUP2_CRICHTEXT_DBGTESTINVARIANT, "Invariant" );

		    }

		__ASSERT_DEBUG(cumulativeParaLength == (DocumentLength() + 1), User::Invariant());

		}

		// Change here for defect INC005336.

		// This defect is present when the assertion below fails.

        if ((iParserData != NULL) &&

                (iParserData->HaveRange()) &&

                (iParserData->EndParse() > DocumentLength()))

            {

            OstTrace0( TRACE_DUMP, DUP3_CRICHTEXT_DBGTESTINVARIANT, "Invariant" );

            }

		__ASSERT_DEBUG( (iParserData == NULL) || \

			(!iParserData->HaveRange()) || \

			(iParserData->EndParse() <= DocumentLength()), User::Invariant());

#endif

	}

EXPORT_C CRichText* CRichText::NewL(const CParaFormatLayer* aGlobalParaLayer,const CCharFormatLayer* aGlobalCharLayer,

									TDocumentStorage aStorage,TInt aDefaultTextGranularity,TParaType aParaType)

/** Allocates and constructs an empty rich text object, with a global character

and paragraph format layer. A single end-of-document delimiter is inserted.

No style list is allocated.

@param aGlobalParaLayer Pointer to the paragraph format layer referenced by

the rich text object. Must not be NULL, or a panic occurs.

@param aGlobalCharLayer Pointer to the character format layer referenced by

the rich text object. Must not be NULL, or a panic occurs.

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

which should rarely need to be changed.

@param aDefaultTextGranularity Specifies the granularity of the in-memory buffer.

Default is EDefaultTextGranularity bytes (=256), and this should rarely need

to be changed.

@param aParaType This argument indicates whether you are using a single paragraph

or multiple paragraphs, and thus affects the granularity of aggregate objects

used internally for storing paragraph attributes. Default = EMultiPara.

@return The rich text object. */

	{

	// Create new rich text containing just a single end-of-document character.

	if (aGlobalParaLayer == NULL)

	    {

	    OstTrace0( TRACE_FATAL, CRICHTEXT_NEWL, "ENullFormatLayerHandle" );

	    }

	__ASSERT_ALWAYS(aGlobalParaLayer != NULL, Panic(ENullFormatLayerHandle));

	if (aGlobalCharLayer == NULL)

	    {

	    OstTrace0( TRACE_FATAL, DUP1_CRICHTEXT_NEWL, "ENullFormatLayerHandle" );

	    }

	__ASSERT_ALWAYS(aGlobalCharLayer != NULL, Panic(ENullFormatLayerHandle));

	CRichText* self = new(ELeave) CRichText(aGlobalParaLayer, aGlobalCharLayer);

	CleanupStack::PushL(self);

	self->ConstructL(aStorage, aDefaultTextGranularity, aParaType);

	CleanupStack::Pop();

	return self;

	}

// Create new rich text that supports Paragraph Styles, containing just a single end-of-document character.

EXPORT_C CRichText* CRichText::NewL(const CParaFormatLayer* aGlobalParaLayer,const CCharFormatLayer* aGlobalCharLayer,

									const CStyleList& aStyleList,

									TDocumentStorage aStorage,TInt aDefaultTextGranularity,TParaType aParaType)

/** Allocates and constructs an empty rich text object which supports styles. It

is constructed with a global character and paragraph format layer and a style

list. A single end-of-document delimiter is inserted. The rich text object

takes ownership of the style list.

Note:

A rich text object not constructed with a style list may still use styles,

by calling SetStyleListExternallyOwned() at any time after construction. In

this case, the rich text object does not own the style list.

@param aGlobalParaLayer Pointer to the paragraph format layer referenced by

the rich text object. Must not be NULL, or a panic occurs.

@param aGlobalCharLayer Pointer to the character format layer referenced by

the rich text object. Must not be NULL, or a panic occurs.

@param aStyleList Style list. Holds the set of paragraph styles which can be

used in the rich text object.

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

which should rarely need to be changed.

@param aDefaultTextGranularity Specifies the granularity of the in-memory buffer.

Default is EDefaultTextGranularity bytes (=256), and this should rarely need

to be changed.

@param aParaType This argument indicates whether you are using a single paragraph

or multiple paragraphs, and thus affects the granularity of aggregate objects

used internally for storing paragraph attributes. Default = EMultiPara.

@return The new rich text object. */

	{

	if (aGlobalParaLayer == NULL)

	    {

	    OstTrace0( TRACE_FATAL, DUP2_CRICHTEXT_NEWL, "ENullFormatLayerHandle" );

	    }

	__ASSERT_ALWAYS(aGlobalParaLayer != NULL, Panic(ENullFormatLayerHandle));

	if (aGlobalCharLayer == NULL)

	    {

	    OstTrace0( TRACE_FATAL, DUP3_CRICHTEXT_NEWL, "ENullFormatLayerHandle" );

	    }

	__ASSERT_ALWAYS(aGlobalCharLayer != NULL, Panic(ENullFormatLayerHandle));

	CRichText* self = new(ELeave) CRichText(aGlobalParaLayer, aGlobalCharLayer, CONST_CAST(CStyleList*, &aStyleList));

	CleanupStack::PushL(self);

	self->ConstructL(aStorage, aDefaultTextGranularity, aParaType);

	CleanupStack::Pop();

	return self;

	}

// Restore into a new rich text object, using the specified global layers.

EXPORT_C CRichText* CRichText::NewL(const CStreamStore& aStore,TStreamId aStreamId,

									const CParaFormatLayer* aGlobalParaLayer,const CCharFormatLayer* aGlobalCharLayer,

									MTextFieldFactory* aFieldFactory,

									TDocumentStorage aStorage)

/** Allocates and constructs a rich text object with a field factory. Its text

content is internalized from a stream store.

Note:

A rich text object not constructed with a field factory may still support

the addition of fields, by calling SetFieldFactory(), defined in the base

class CPlainText.

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

@param aStreamId ID of the stream store.

@param aGlobalParaLayer Pointer to the paragraph format layer referenced by

the rich text object. Must not be NULL, or a panic occurs.

@param aGlobalCharLayer Pointer to the character format layer referenced by

the rich text object. Must not be NULL, or a panic occurs.

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

if the text object supports fields.

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

which should rarely need to be changed.

@return The new rich text object. */

	{

	if (aGlobalParaLayer == NULL)

	    {

	    OstTrace0( TRACE_FATAL, DUP4_CRICHTEXT_NEWL, "ENullFormatLayerHandle" );

	    }

	__ASSERT_ALWAYS(aGlobalParaLayer != NULL, Panic(ENullFormatLayerHandle));

	if (aGlobalCharLayer == NULL)

	    {

	    OstTrace0( TRACE_FATAL, DUP5_CRICHTEXT_NEWL, "ENullFormatLayerHandle" );

	    }

	__ASSERT_ALWAYS(aGlobalCharLayer != NULL, Panic(ENullFormatLayerHandle));

	CRichText* self = new(ELeave) CRichText(aGlobalParaLayer, aGlobalCharLayer);

	CleanupStack::PushL(self);

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

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CRichText* CRichText::NewL(const CStreamStore& aStore, TStreamId aStreamId,

									const CParaFormatLayer* aGlobalParaLayer, const CCharFormatLayer* aGlobalCharLayer,

									MPictureFactory* aPictureFactory, MRichTextStoreResolver* aStoreResolver,

									MTextFieldFactory* aFieldFactory,

									TDocumentStorage aStorage)

/** Allocates and constructs a rich text object with a field factory and a picture

factory. Its text content is internalized from a stream store.

Note:

A rich text object not constructed with a field factory may still support

the addition of fields, by calling SetFieldFactory(), defined in the base

class CPlainText.

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

@param aStreamId ID of the stream store.

@param aGlobalParaLayer Pointer to the paragraph format layer referenced by

the rich text object. Must not be NULL, or a panic occurs.

@param aGlobalCharLayer Pointer to the character format layer referenced by

the rich text object. Must not be NULL, or a panic occurs.

@param aPictureFactory The picture factory. This is needed to load pictures

into memory, (see PictureHandleL()). If a store resolver is specified (not

NULL), then a factory must also be specified, or a panic occurs.

@param aStoreResolver A store resolver. This determines which file store the

picture is stored in. It is used to get from a reference to an embedded picture

within a CRichText object to the actual picture itself. Picture loading is

done by the picture factory.

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

if the text object supports fields.

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

which should rarely need to be changed.

@return The new rich text object. */

	{

	// Restore a new rich text from the specified stream, that uses the specified global layers, and the

	// specified picture header factory and store, if this rich text supports pictures.

	if (!aPictureFactory && aStoreResolver)

	    {

	    OstTrace0( TRACE_FATAL, DUP6_CRICHTEXT_NEWL, "EInvalidPictureFactorySettings" );

	    }

	__ASSERT_ALWAYS(!(!aPictureFactory && aStoreResolver), Panic(EInvalidPictureFactorySettings));

	if (aGlobalParaLayer == NULL)

	    {

	    OstTrace0( TRACE_FATAL, DUP7_CRICHTEXT_NEWL, "ENullFormatLayerHandle" );

	    }

	__ASSERT_ALWAYS(aGlobalParaLayer != NULL, Panic(ENullFormatLayerHandle));

	if (aGlobalCharLayer == NULL)

	    {

	    OstTrace0( TRACE_FATAL, DUP8_CRICHTEXT_NEWL, "ENullFormatLayerHandle" );

	    }

	__ASSERT_ALWAYS(aGlobalCharLayer != NULL, Panic(ENullFormatLayerHandle));

	CRichText* self = new(ELeave) CRichText(aGlobalParaLayer, aGlobalCharLayer);

	CleanupStack::PushL(self);

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

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CRichText::CRichText(const CParaFormatLayer* aGlobalParaLayer, const CCharFormatLayer* aGlobalCharLayer,

							  CStyleList* aStyleList):

	CGlobalText(aGlobalParaLayer, aGlobalCharLayer),

	iStyleList(aStyleList)

	{

	}

EXPORT_C void CRichText::ConstructL(TDocumentStorage aStorage, TInt aDefaultTextGranularity, TParaType aParaType)

// Initialises and updates the index following the CPlainText::ConstructL

// insertion of the end-of-document character.

//

	{

	CPlainText::ConstructL(aStorage, aDefaultTextGranularity);

	SetParaTypeIsSingle(aParaType == ESinglePara);

	iParserData = new(ELeave) CParserData(DocumentLength());

	TInt a;

	TInt b;

	ParseText(a, b, ETrue);

	__TEST_INVARIANT;

	}

EXPORT_C void CRichText::ConstructL(const CStreamStore& aStore,TStreamId aStreamId,

									MPictureFactory* aPictureFactory, MRichTextStoreResolver* aStoreResolver,

									MTextFieldFactory* aFieldFactory,

									TDocumentStorage aStorage)

// Initialises and updates the index following the CPlainText::ConstructL

// insertion of the end-of-document character.

// Sets the picture header factory if provided.

//

	{

	CPlainText::ConstructL(aStore, aStreamId, aFieldFactory, aStorage);

	SetPictureFactory(aPictureFactory, aStoreResolver);

	if (iParserData == NULL)

		iParserData = new(ELeave) CParserData(DocumentLength());

	TInt a;

	TInt b;

	ParseText(a, b, ETrue);

	__TEST_INVARIANT;

	}

EXPORT_C CRichText::~CRichText()

/** The destructor frees all resources owned by the rich text object, prior to

its destruction. */

	{

	// We cannot call DestroyParserSystem() here because it applies to all instances in the thread

	delete iParserData;

	KillStyleList();

	KillIndex();

	}

void CRichText::KillStyleList()

// Free up the style table

//

	{

	if (StyleListPresent() && !StyleListExternallyOwned())

		{

		delete iStyleList.AsPtr();

		iStyleList = NULL;

		}

	}

void CRichText::KillIndex()

// Delete the rich text index if it's resident in memory.

//

	{

	if (IndexPresent())

		delete iIndex.AsPtr();

	iIndex=NULL;

	}

TBool CRichText::CreateEmptyMarkupComponentL()

// If necessary, creates an empty markup component.

// Returns ETrue if the markup component was created as a result of this function,

// otherwise returns EFalse.

//

	{

	if (IndexPresent())

		return EFalse;

	TInt paraGran = (ParaTypeIsSingle()) ? KSingleParaGranularity : KMultiParaGranularity;

	TInt phrGran = (ParaTypeIsSingle()) ? KSmallPhraseGranularity : KLargePhraseGranularity;

	iIndex = CRichTextIndex::NewL(iGlobalParaFormatLayer, iGlobalCharFormatLayer, *this,paraGran,phrGran);

	return ETrue;

	}

void CRichText::CreateAndGenerateMarkupComponentL()

// Checks if the rich text index needs to be created and does so if necessary.

// Called by all public rich text functions that manipulate specific formatting.

//

	{

	if (CreateEmptyMarkupComponentL())

		{

		TRAPD(ret, GenerateMarkupL());

		if (ret != KErrNone)

			{// destroy this partially set markup component

			delete iIndex.AsPtr();

			iIndex = NULL;

			User::Leave(ret);

			}

		}

	}

void CRichText::GenerateMarkupL()

// Generate markup data corresponding to the current text content.

//

	{

	TInt remainingLength = DocumentLength();

	TInt startPos = 0;

	while (remainingLength)

		{

		TPtrC buf = Read(startPos);

		TInt consumed = buf.Length();

		if (consumed > remainingLength)

			{

			consumed = remainingLength;

			buf.Set(buf.Ptr(), consumed);

			}

		iIndex->InsertL(startPos, buf, *iGlobalParaFormatLayer);

		remainingLength -= consumed;

		startPos += consumed;

		}

	}

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

/** Copies a portion of the rich text object, with components to the clipboard.

A panic occurs in the following circumstances:

aPos is an invalid document position

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

		{

		TStreamId plainTextId = CPlainText::DoCopyToStoreL(aStore,aDictionary,aPos,aLength);

		TStreamId id = DoCopyToStoreL(aStore,aPos,aLength,plainTextId,FALSE);

		aDictionary.AssignL(KClipboardUidTypeRichText,id);

		TStreamId idStyles = DoCopyToStoreL(aStore,aPos,aLength,plainTextId,TRUE);

		aDictionary.AssignL(KClipboardUidTypeRichTextWithStyles,idStyles);

		}

	}

// Copy the selected region of rich text, with components, to the specified store.

TStreamId CRichText::DoCopyToStoreL(CStreamStore& aStore,TInt aPos,TInt aLength,TStreamId aPlainTextId,TBool aCopyStyles) const

	{

	__TEST_INVARIANT;

	TInt documentLength = DocumentLength();

	if (aPos < 0 || aPos > documentLength)

	    {

	    OstTrace0( TRACE_FATAL, CRICHTEXT_DOCOPYTOSTOREL, "ECharPosBeyondDocument" );

	    }

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

	if (aLength < 0)

	    {

	    OstTrace0( TRACE_FATAL, DUP1_CRICHTEXT_DOCOPYTOSTOREL, "ECopyToClipboardNegativeLength" );

	    }

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

	if (aPos + aLength > documentLength)

	    {

	    OstTrace0( TRACE_FATAL, DUP2_CRICHTEXT_DOCOPYTOSTOREL, "ECharPosBeyondDocument" );

	    }

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

	if (aLength == 0)

		return KNullStreamId;

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

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

	RStoreWriteStream stream(*map);

	TStreamId id = stream.CreateLC(aStore);

	CopyToStreamL(stream,aPos,aLength,aPlainTextId,aCopyStyles);

	stream.CommitL();

	map->Reset();

	CleanupStack::PopAndDestroy(2);

	__TEST_INVARIANT;

	return id;

	}

EXPORT_C void CRichText::CopyComponentsL(CStreamStore& aStore,CStoreMap& aMap,TInt aPos,TInt aLength,TStreamId aPlainTextId) const

	{

	if (aPlainTextId == KNullStreamId)

		CPlainText::CopyComponentsL(aStore,aMap,aPos,aLength);

	if (IndexPresent())

		iIndex->StorePicturesL(aStore,aMap,aPos,aLength);

	}

// Copy the selected region of rich text and components to the specified stream.

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

	{

	__TEST_INVARIANT;

	CopyToStreamL(aStream, aPos, aLength, KNullStreamId);

	}

/*

Copy the selected region of rich text and components to the specified stream.

If aPlainTextId is NULL the plain text component is stored in-line,

otherwise the reference to the plain text stream component is stored.

*/

EXPORT_C void CRichText::CopyToStreamL(RWriteStream& aStream,TInt aPos,TInt aLength,TStreamId aPlainTextId) const

	{

	CopyToStreamL(aStream,aPos,aLength,aPlainTextId,TRUE);

	}

void CRichText::CopyToStreamL(RWriteStream& aStream,TInt aPos,TInt aLength,TStreamId aPlainTextId,TBool aCopyStyles) const

	{

	if (aPlainTextId == KNullStreamId)

		{

		aStream.WriteUint8L(TRUE);

		CPlainText::CopyToStreamL(aStream,aPos,aLength);

		}

	else

		{

		aStream.WriteUint8L(FALSE);

		aStream << aPlainTextId;

		}

	if (!IndexPresent())

		CONST_CAST(CRichText*,this)->CreateAndGenerateMarkupComponentL();

	aStream.WriteUint8L(TRUE);

	iIndex->CopyToStreamL(aStream,aPos,aLength,aCopyStyles);

	}

EXPORT_C TInt CRichText::PasteFromStoreL(const CStreamStore& aStore, const CStreamDictionary& aDictionary, TInt aPos, CParagraphStyle::TStylePasteMode aStylePasteMode)

/** Pastes the contents of the clipboard into the rich text object at the

specified document position. Returns the number of characters pasted.

If the text in the clipboard has been formatted using styles, the

aStylePasteMode argument indicates whether the styles should be preserved

or discarded. If the argument is not specified, the pasted rich text

retains all formatting specified in the styles, and any new style

definitions are added to the style list of the rich text object into which

it is pasted.

@param aStore The stream store from which to paste the rich text.

@param aDictionary The stream dictionary.

@param aPos The document position at which to paste the rich text. Must be

valid, or a panic occurs.

@param aStylePasteMode Indicates whether styles in the pasted text should be

preserved or discarded.

@return The number of characters pasted. */

	{

	return DoPasteRtFromStoreL(aStore, aDictionary, aPos, aStylePasteMode);

	}

EXPORT_C TInt CRichText::PasteFromStoreL(const CStreamStore& aStore, const CStreamDictionary& aDictionary, TInt aPos)

// Paste the lesser of i) aMaxPasteLength ii) the entire clipboard contents.

// Return a count of the number of characters pasted.

//

	{

	return DoPasteRtFromStoreL(aStore, aDictionary, aPos, CParagraphStyle::EAddNewStyles);

	}

TInt CRichText::DoPasteRtFromStoreL(const CStreamStore& aStore, const CStreamDictionary& aDictionary, TInt aPos, CParagraphStyle::TStylePasteMode aStylePasteMode)

// Paste the rich text data from the specified clipboard, inserting it into this

// instance at character position aPos.  Returns the number of characters pasted.

// May be 0.

//

	{

	__TEST_INVARIANT;

	if (aPos > DocumentLength())

	    {

	    OstTrace0( TRACE_FATAL, CRICHTEXT_DOPASTERTFROMSTOREL, "ECharPosBeyondDocument" );

	    }

	__ASSERT_ALWAYS(aPos <= DocumentLength(), Panic(ECharPosBeyondDocument));

	TUid type = KClipboardUidTypeRichTextWithStyles;

	TStreamId id = aDictionary.At(type);

	if (id == KNullStreamId)

		{

		type = KClipboardUidTypeRichText;

		id = aDictionary.At(type);

		}

	if (id == KNullStreamId)

		{

		type = KClipboardUidTypePlainText;

		id = aDictionary.At(type);

		}

	TInt consumed = 0;

	if (id == KNullStreamId)

		return consumed;

	if (type == KClipboardUidTypeRichText || type == KClipboardUidTypeRichTextWithStyles)

		consumed = PasteRichTextFromStoreL(aStore, aDictionary, id, aPos, aStylePasteMode);

	else if (type == KClipboardUidTypePlainText)

		consumed = PastePlainTextFromStoreL(aStore, id, aPos);

	if (consumed)

		{

		iParserData->MergeRange(aPos,0,consumed);

		CallEditObserver(aPos, consumed);

		}

	SetHasChanged(ETrue);

	__TEST_INVARIANT;

	return consumed;

	}

TInt CRichText::PasteRichTextFromStoreL(const CStreamStore& aStore, const CStreamDictionary& aDictionary, TStreamId& aRichTextStreamId, TInt aPos,CParagraphStyle::TStylePasteMode aStylePasteMode)

// Paste the plain text stream, then open and paste the rich text markup from the specified stream.

//

	{

	if (!IndexPresent())

		CreateAndGenerateMarkupComponentL();  // create the index if it does not already exist

	TStreamId id = aDictionary.At(KClipboardUidTypePlainText);

// ASSERT: We have rich text, so the plain text stream must exist.

	if (id == KNullStreamId)

	    {

	    OstTrace0( TRACE_FATAL, CRICHTEXT_PASTERICHTEXTFROMSTOREL, "EClipboardIntegrity" );

	    }

	__ASSERT_ALWAYS(id != KNullStreamId,Panic(EClipboardIntegrity));

	TInt consumed = CPlainText::DoPasteFromStoreL(aStore, id, aPos);

	TRAPD(ret, CompletePasteRichTextFromStoreL(aStore, aRichTextStreamId, aPos, aStylePasteMode));

	if (ret != KErrNone)

		{

		CPlainText::Delete(aPos,consumed);

		OstTrace1( TRACE_FATAL, DUP1_CRICHTEXT_PASTERICHTEXTFROMSTOREL, "Leave code=%d", ret );

		User::Leave(ret);

		}

	return consumed;

	}

void CRichText::CompletePasteRichTextFromStoreL(const CStreamStore& aStore, TStreamId& aRichTextStreamId, TInt aPos, CParagraphStyle::TStylePasteMode aStylePasteMode)

//

	{

	RStoreReadStream stream;

	stream.OpenLC(aStore, aRichTextStreamId);

	TBool plainTextInline = (TBool)stream.ReadUint8L();

	if (!plainTextInline)

		{

		TStreamId dummy;

		stream >> dummy;

		}

	TBool markupPresentInClipboard = (TBool)stream.ReadUint8L();

	if (markupPresentInClipboard)

		iIndex->PasteFromStreamL(aStore, stream, aPos,aStylePasteMode, iGlobalParaFormatLayer, iGlobalCharFormatLayer);

	CleanupStack::PopAndDestroy();  // stream

	}

TInt CRichText::PastePlainTextFromStoreL(const CStreamStore& aStore, TStreamId& anId, TInt aPos)

// Paste the plain text stream, then update the rich text index to show any paragraph delimiters pasted.

//

	{

	TInt consumed = CPlainText::DoPasteFromStoreL(aStore, anId, aPos);

	//

	if (IndexPresent())

		{

		TRAPD(ret, CompletePastePlainTextL(aPos, consumed));

		if (ret != KErrNone)

			{

			CPlainText::Delete(aPos,consumed);

			User::Leave(ret);

			}

		}

	return consumed;

	}

void CRichText::CompletePastePlainTextL(TInt aPos, TInt aCharacterCount)

// Updates the rich text index following the pasting of global text.

//

	{

	HBufC* buf = HBufC::NewLC(aCharacterCount);

	TPtr bf = buf->Des();

	Extract(bf, aPos, aCharacterCount);

	iIndex->InsertL(aPos, bf, *iGlobalParaFormatLayer);

	CleanupStack::PopAndDestroy();  // buf

	}

EXPORT_C void CRichText::Reset()

/** Resets the document's contents to a single end-of-document delimiter. Also

deletes the style list if owned by the object. */

	{

	// Resets document contents to single end-of-document charcter,

	// and resets the index to match document content.

	TInt length = DocumentLength();

	CPlainText::Reset();  // remove all content bar eod character

	KillStyleList();  // does not get destroyed if externally owned

	KillIndex();

	SetHasChanged(ETrue);

	iParserData->KillRange();

	iParserData->iLastKnownCursor = -1;

	CallEditObserver(0, -length);

	__TEST_INVARIANT;

	}

EXPORT_C void CRichText::InsertL(TInt aPos, const TChar& aChar)

/** Inserts either a single character or a descriptor into the text object

at a specified document position.

The insertion position must be valid or a panic occurs.Note:A panic

occurs if the text object is in an "insert pending" state (i.e.

SetInsertCharFormatL() has been called and has not been

cancelled using CancelInsertCharFormat()) and aPos is not

the same as the insertion point.

@param aPos The document position at which to insert the character/descriptor.

@param aChar The character to insert. Must not be a picture character or a

panic occurs.

@param aBuf The descriptor to insert. */

	{

	__TEST_INVARIANT;

	if (aPos < 0 || aPos > DocumentLength())

	    {

	    OstTrace0( TRACE_FATAL, CRICHTEXT_INSERTL, "ECharPosBeyondDocument" );

	    }

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

	if (aChar == EPictureCharacter)

	    {

	    OstTrace0( TRACE_FATAL, DUP1_CRICHTEXT_INSERTL, "ENonOverloadedInsertCalledWithPictureCharacter" );

	    }

	__ASSERT_ALWAYS(aChar!= EPictureCharacter, Panic(ENonOverloadedInsertCalledWithPictureCharacter));

	if (aChar < 0x10000)

		{

		TBuf<1> content;

		content.Append(aChar);

		RtInsertL(aPos, content);

		}

	else

		{

		TText16 high = TChar::GetHighSurrogate(aChar);

		TText16 low = TChar::GetLowSurrogate(aChar);

		RDebug::Print(_L("CRichText::InsertL(), %X expand to %X %X."), TUint(aChar), high, low);

		TBuf<2> content;

		content.Append(high);

		content.Append(low);

		RtInsertL(aPos, content);

		}

	__TEST_INVARIANT;

	}

EXPORT_C void CRichText::InsertL(TInt aPos, const TDesC& aBuf)

// Inserts the contents of aBuf into the text component at character position aPos.

//

	{

	__ETEXT_WATCH(INSERT_DESC);

	RtInsertL(aPos, aBuf);

	__ETEXT_WATCH_END(INSERT_DESC);

	}

EXPORT_C void CRichText::RtInsertL(TInt aPos, const TDesC& aBuf)

// Inserts the contents a aBuf into the text component at position aPos.

// Updates the index accordingly, and accounts for all embedded paragraph delimiters

// in the passed buffer aBuf.

//

	{

	__TEST_INVARIANT;

	if (aPos < 0 || aPos > DocumentLength())

	    {

	    OstTrace0( TRACE_FATAL, CRICHTEXT_RTINSERTL, "ECharPosBeyondDocument" );

	    }

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

	int length = aBuf.Length();

	CPlainText::InsertL(aPos, aBuf);

	if (IndexPresent())

		{

		TRAPD(ret, iIndex->InsertL(aPos, aBuf, *iGlobalParaFormatLayer));

		if (ret != KErrNone)

			{

			CPlainText::Delete(aPos,length);

			User::Leave(ret);

			}

		SetHasChanged(ETrue);

		}

	iParserData->MergeRange(aPos,0,length);

	CallEditObserver(aPos,length);

	__TEST_INVARIANT;

	}

EXPORT_C void CRichText::InsertL(TInt aPos,const TPictureHeader& aHeader)

/**Inserts a picture header into the text object at a specified document

position. The picture header specified must reference a valid picture, or

a panic occurs.

A panic also occurs if the text object is in an "insert pending" state

(SetInsertCharFormatL() has been called and has not been cancelled using

CancelInsertCharFormat()) and aPos is not the same as the insertion point.

This method takes ownership of a picture referenced in aHeader.

@param aPos The document position at which to insert the picture header. Must

be valid, or a panic occurs.

@param aHeader A picture header. This holds a pointer to the picture to insert,

and information about the picture. */

	{

	__TEST_INVARIANT;

	if (aPos < 0 || aPos > DocumentLength())

	    {

	    OstTrace0( TRACE_FATAL, DUP2_CRICHTEXT_INSERTL, "ECharPosBeyondDocument" );

	    }

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

	CleanupStack::PushL(aHeader.iPicture);

	if (!IndexPresent())

		CreateAndGenerateMarkupComponentL();

	TBuf<1> picture;

	picture.Append(EPictureCharacter);

	CPlainText::InsertL(aPos, picture);

    CleanupStack::Pop(aHeader.iPicture);

	TBool pictureOwnershipTaken(EFalse);

	TRAPD(ret, iIndex->InsertL(aPos, aHeader,pictureOwnershipTaken));

	if (ret != KErrNone)

		{

		if(!pictureOwnershipTaken)

		    {

		    const_cast <TPictureHeader&> (aHeader).DeletePicture();

		    }

		CPlainText::Delete(aPos,picture.Length());  // remove the picture place-holder

    	User::Leave(ret);

		}

	SetHasChanged(ETrue);

	iParserData->MergeRange(aPos,0,1);

	CallEditObserver(aPos,1);

	__TEST_INVARIANT;

	}

EXPORT_C TBool CRichText::DeleteL(TInt aPos, TInt aLength)

/** Deletes one or more characters beginning at, and including, the character at

a specified document position. Can leave because paragraphs may be merged

and reformatted by the function.

@param aPos The start of the range of characters to delete. Must be valid

or a panic occurs.

@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 as a result of the

delete, indicating that the formatting of part of the resulting paragraph

may have changed. */

	{

	// Deletes aRange number of characters from the text component

	// and the corresponding index data.

	// Delete commences at, and includes, character position aPos.

	__TEST_INVARIANT;

	if (aPos < 0 || aPos > DocumentLength())

	    {

	    OstTrace0( TRACE_FATAL, CRICHTEXT_DELETEL, "ECharPosBeyondDocument" );

	    }

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

	if (aLength < 0)

	    {

	    OstTrace0( TRACE_FATAL, DUP1_CRICHTEXT_DELETEL, "EDebugDeleteZeroLength" );

	    }

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

	if (aPos + (aLength - 1) > DocumentLength())

	    {

	    OstTrace0( TRACE_FATAL, DUP2_CRICHTEXT_DELETEL, "ECharPosBeyondDocument" );

	    }

	__ASSERT_ALWAYS(aPos + (aLength - 1) <= DocumentLength(), Panic(ECharPosBeyondDocument));

	TBool requireMerge = EFalse;

	if (!IndexPresent())

		CPlainText::Delete(aPos,aLength);

	else

		{

		iIndex->CancelInsertCharFormat();

		TIndexDeleteInfo info;

		iIndex->SetForDeleteL(info, aPos, aLength);

		CPlainText::Delete(aPos,aLength);

		requireMerge = iIndex->DeleteNow(info);

		}

	iParserData->MergeRange(aPos,aLength,0);

	CallEditObserver(aPos,-aLength);

	__TEST_INVARIANT;

	return requireMerge;

	}

EXPORT_C void CRichText::DeleteParagraph(TInt aPos, TInt aLength)

/** Deletes one or more whole paragraphs of text. No paragraphs can be merged together

by this function, so it cannot leave it must only be used to delete entire

paragraphs.

@param aPos The document position of the start of the first paragraph to delete.

Must be a valid position or a panic occurs.

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

	{

	// Use to remove entire paragraphs of text.

	// Leave-safe if called in this context.

	// MUST NOT CALL if not in this context.

	__TEST_INVARIANT;

	// Store the length of the text before we commence with deletions.

	TInt initialDocLen=DocumentLength();

	if (aPos < 0 || aPos > initialDocLen)

	    {

	    OstTrace0( TRACE_FATAL, CRICHTEXT_DELETEPARAGRAPH, "ECharPosBeyondDocument" );

	    }

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

	if (aPos + aLength > initialDocLen + 1)

	    {

	    OstTrace0( TRACE_FATAL, DUP1_CRICHTEXT_DELETEPARAGRAPH, "ECharPosBeyondDocument" );

	    }

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

	if (aLength <= 0)

		return;

	if (IndexPresent())

		iIndex->DeleteParagraph(aPos, aLength);

	CPlainText::Delete(aPos,aLength);

	// Change here for defect INC005336.

	// Previously the MergeRange call (see else line) was incorrectly handling

	// the scenario where all but the first paragraph was deleted e.g. pasting

	// multi line buffer into a single line text control in a new email on Techview

	// emulator.

	// This was because the deletion in the two lines above would delete the

	// 'end-of-text' maker causing the iEndParse member of CParserData to

	// index the char right after the end of test marker. This would panic

	// plugin parsers thatsubsquently executed.

	if (aPos+aLength > initialDocLen)

		// When deletion includes the end-of-text marker, adjust start

		// supplied so that it appears to MergeRange that we are

		// deleting the paragraph and CR just before it which belongs

		// to the previous paragraph and not the end-of-text marker.

		// This is actually the end result of the deletion anyway!

		iParserData->MergeRange(initialDocLen-aLength,aLength,0);

	else

		// All other deletions which don't.

		iParserData->MergeRange(aPos,aLength,0);

	CallEditObserver(aPos,-aLength);

	__TEST_INVARIANT;

	}

EXPORT_C void CRichText::DeleteFromParagraph(TInt aPos, TInt aLength)

/** Removes a range of characters from within a single paragraph only. Should not

be used for deleting an entire paragraph or paragraphs because this may cause

it to leave. Otherwise, it is guaranteed not to leave.

@param aPos The document position of the start of the range of characters

to delete. Must be a valid document position, or a panic occurs.

@param aLength The number of characters to delete. The sum of aPos and aLength

must be less than the document length, or a panic occurs. */

	{

	// Removes aLength characters from *within* a single paragraph only.

	// Guaranteed not to leave if this pre-condition holds true.

	__TEST_INVARIANT;

	if (aPos < 0 || aPos > DocumentLength())

	    {

	    OstTrace0( TRACE_FATAL, CRICHTEXT_DELETEFROMPARAGRAPH, "ECharPosBeyondDocument" );

	    }

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

	if (aPos + (aLength - 1) > DocumentLength())

	    {

	    OstTrace0( TRACE_FATAL, DUP1_CRICHTEXT_DELETEFROMPARAGRAPH, "ECharPosBeyondDocument" );

	    }

	__ASSERT_ALWAYS(aPos + (aLength - 1) <= DocumentLength(), Panic(ECharPosBeyondDocument));

	if (aLength <= 0)

		return;

	if (IndexPresent())

		iIndex->DeleteFromParagraph(aPos, aLength);

	CPlainText::Delete(aPos,aLength);

	iParserData->MergeRange(aPos,aLength,0);

	CallEditObserver(aPos,-aLength);

	__TEST_INVARIANT;

	}

EXPORT_C TInt CRichText::ParagraphCount()const

/** Gets a count of the number of paragraphs in the text object.

Note:

The paragraph delimiter which terminates every text object means this function