/*

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

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

	__ASSERT_DEBUG(iGlobalParaFormatLayer != NULL, User::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;

			}

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

		}

		// Change here for defect INC005336.

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

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

	__ASSERT_ALWAYS(aGlobalParaLayer != NULL, Panic(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. */

	{

	__ASSERT_ALWAYS(aGlobalParaLayer != NULL, Panic(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. */

	{

	__ASSERT_ALWAYS(aGlobalParaLayer != NULL, Panic(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.

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

	__ASSERT_ALWAYS(aGlobalParaLayer != NULL, Panic(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();

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

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

	__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;

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