/*

* 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 <gdi.h>

#include <s32stor.h>

#include "TXTFMLYR.H"

#include "TXTETEXT.H"

#include "TXTLAYDC.H"

#include "TXTSTYLE.H"

#include "TXTINDEX.H"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "TXTINDEXTraces.h"

#endif

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "TXTFMLYR_INTERNAL.H"

#include "TXTSTYLE_INTERNAL.H"

#endif

TGlobalLayerInfoAppend::TGlobalLayerInfoAppend()

	: iAggParaFormatLayer(NULL),iAggCharFormatLayer(NULL),iComParaFormatLayer(NULL),iComCharFormatLayer(NULL)

	{}

TGlobalLayerInfoAppend::TGlobalLayerInfoAppend(const CParaFormatLayer* aAggParaFormatLayer,const CCharFormatLayer* aAggCharFormatLayer,

							const CParaFormatLayer* aComParaFormatLayer,const CCharFormatLayer* aComCharFormatLayer)

	: iAggParaFormatLayer(aAggParaFormatLayer),iAggCharFormatLayer(aAggCharFormatLayer),

	  iComParaFormatLayer(aComParaFormatLayer),iComCharFormatLayer(aComCharFormatLayer)

	{}

TTextFragment::TTextFragment():

	iLength(0),

	iPhraseCount(0)

	{

	}

TCurrentIndexRecords::TCurrentIndexRecords()

	{

	}

DLLEXPORT_C void CRichTextIndex::__DbgTestInvariant()const

// Provides class invariants.  Explanations below:

//

	{

#ifdef _DEBUG

// ASSERT: Every phrase index is consistent with its corresponding paragraph.

	TInt zeroLengthPhraseCount=0;

	TInt maxPara=iParaIx->Count();

	TInt numberOfReferencesToSharedList=0;

	TInt currentPhraseElement=0;

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

		{

		// ASSERT: The basedOn link is valid.

		CFormatLayer* thisLayer=(*iParaIx)[para].iParaAttribs->iParaFormat;

		CFormatLayer* base=CONST_CAST(CFormatLayer*,thisLayer->SenseBase());

		if (base==NULL)

		    {

		    OstTrace0( TRACE_DUMP, CRICHTEXTINDEX_DBGTESTINVARIANT, "base==NULL" );

		    }

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

		if ((*iParaIx)[para].iParaAttribs->iRefCount>0)

			numberOfReferencesToSharedList++;

		TInt paragraphLength=(*iParaIx)[para].iLength;

		TInt sumOfPhraseLengths=0;

		TInt maxPhrase=(*iParaIx)[para].iParaAttribs->PhraseCount();

		for (TInt phrase=0;phrase<maxPhrase;phrase++)

			{

			if (maxPhrase>1)

				{

				const RPhraseAttribsEntry* phrase=&(*iPhraseIx)[currentPhraseElement];

				CCharFormatLayer* charFormatLayer=phrase->CharFormat();

				// ASSERT: The basedOn link is valid.

				if (charFormatLayer->SenseBase()==NULL)

				    {

				    OstTrace0( TRACE_DUMP, DUP1_CRICHTEXTINDEX_DBGTESTINVARIANT, "charFormatLayer->SenseBase()==NULL" );

				    }

				__ASSERT_DEBUG(charFormatLayer->SenseBase()!=NULL,User::Invariant());

				if (TInt(charFormatLayer->SenseBase())<=0x1000)

				    {

				    OstTrace0( TRACE_DUMP, DUP2_CRICHTEXTINDEX_DBGTESTINVARIANT, "TInt(charFormatLayer->SenseBase())<=0x1000" );

				    }

				__ASSERT_DEBUG(TInt(charFormatLayer->SenseBase())>0x1000,User::Invariant());

				sumOfPhraseLengths+=(*iPhraseIx)[currentPhraseElement].Length();

				if ((*iPhraseIx)[currentPhraseElement].Length()==0)

					zeroLengthPhraseCount++;

				currentPhraseElement++;

				}

			else

				{

				CCharFormatLayer* charFormatLayer=(*iParaIx)[para].iParaAttribs->iCharFormat;

				// ASSERT: The basedOn link is valid.

				if (charFormatLayer->SenseBase()==NULL)

				    {

				    OstTrace0( TRACE_DUMP, DUP3_CRICHTEXTINDEX_DBGTESTINVARIANT, "charFormatLayer->SenseBase()==NULL" );

				    }

				__ASSERT_DEBUG(charFormatLayer->SenseBase()!=NULL,User::Invariant());

				sumOfPhraseLengths+=(*iParaIx)[para].iLength;

				}

			}

		if (sumOfPhraseLengths!=paragraphLength)

		    {

		    OstTrace0( TRACE_DUMP, DUP4_CRICHTEXTINDEX_DBGTESTINVARIANT, "sumOfPhraseLengths!=paragraphLength" );

		    }

		__ASSERT_DEBUG(sumOfPhraseLengths==paragraphLength,User::Invariant());

		}

// ASSERT: We have no unexpected phrases left over

	if (currentPhraseElement!=-1 &&

            currentPhraseElement!=iPhraseIx->Count())

	    {

	    OstTrace0( TRACE_DUMP, DUP5_CRICHTEXTINDEX_DBGTESTINVARIANT, "We have no unexpected phrases left over" );

	    }

	__ASSERT_DEBUG(currentPhraseElement==-1 ||

					currentPhraseElement==iPhraseIx->Count(),User::Invariant());

// ASSERT: There is either zero(0) or one(1) zero length phrase in the whole index

	if (!((zeroLengthPhraseCount==0) ||

            (zeroLengthPhraseCount==1 && iPendingNewPhrasePos!=EInsertCharFormatReset)))

	    {

	    OstTrace0( TRACE_DUMP, DUP6_CRICHTEXTINDEX_DBGTESTINVARIANT, "There is either zero(0) or one(1) zero length phrase in the whole index" );

	    }

	__ASSERT_DEBUG( (zeroLengthPhraseCount==0) ||

					(zeroLengthPhraseCount==1 && iPendingNewPhrasePos!=EInsertCharFormatReset),

					User::Invariant());

// ASSERT: the number of paraEntries with paraAttribs of refCount>0 == the sum of refCounts in the shared list.

//			or is only one less - as is set when SetInsertCharFormat is called on a shared paraAttribs.

	TInt totalReferenceCount=0;

	if (!iSharedParaQueHead.IsEmpty())

		{

		CParaAttribs* currentSharedPara;

		TDblQueIter<CParaAttribs> iterator(((CRichTextIndex*)this)->iSharedParaQueHead);

		while ((currentSharedPara=iterator++)!=NULL)

			totalReferenceCount+=currentSharedPara->iRefCount;

		}

	if ((numberOfReferencesToSharedList!=totalReferenceCount) &&

            (numberOfReferencesToSharedList!=totalReferenceCount-1))

	    {

	    OstTrace0( TRACE_DUMP, DUP7_CRICHTEXTINDEX_DBGTESTINVARIANT, "Invariant" );

	    }

	__ASSERT_DEBUG((numberOfReferencesToSharedList==totalReferenceCount) ||

				   (numberOfReferencesToSharedList==totalReferenceCount-1),User::Invariant());

// ASSERT: iPictureCount corresponds to the number of pictures in the stored in the index.

	TInt picCount=0;

	TInt phraseCount=(iPhraseIx) ? iPhraseIx->Count() : 0;

	for (TInt item=0;item<phraseCount;item++)

		picCount+=((*iPhraseIx)[item].IsPicturePhrase())

					? 1

					: 0;

	if (iPictureCount!=picCount)

	    {

	    OstTrace0( TRACE_DUMP, DUP8_CRICHTEXTINDEX_DBGTESTINVARIANT, "Invariant" );

	    }

	__ASSERT_DEBUG(iPictureCount==picCount,User::Invariant());

#endif

	}

CRichTextIndex* CRichTextIndex::NewL(const CParaFormatLayer* aGlobalParaLayer,const CCharFormatLayer* aGlobalCharLayer,

									 const CRichText& aText,TInt aParaGran,TInt aPhraseGran)

// Return a handle to a new instance of this class.

// Requires the global format layer handles on which to base the first content.

//

	{

	CRichTextIndex* self=new(ELeave) CRichTextIndex(aText);

	CleanupStack::PushL(self);

	self->ConstructL(aGlobalParaLayer,aGlobalCharLayer,aParaGran,aPhraseGran);

	CleanupStack::Pop();

	return self;

	}

CRichTextIndex::CRichTextIndex(const CRichText& aText):

	iText(aText),

	iPendingNewPhrasePos(EInsertCharFormatReset),

	iSharedParaQueHead(_FOFF(CParaAttribs,link))

	{

	}

void CRichTextIndex::ConstructL(const CParaFormatLayer* aGlobalParaLayer,const CCharFormatLayer* aGlobalCharLayer,TInt aParaGran,TInt aPhraseGran)

// Provides a fully initialised rich text index.

// Upon construction, the index contains a single paragraph of length 1 (para.terminator).

// This first paragraph initially has constant character formatting, ie the shared para list

// must have one item in it.

//

	{

	CParaFormatLayer* paraLayer=CParaFormatLayer::NewL();  // Creates empty layer.

	paraLayer->SetBase(aGlobalParaLayer);  // Sets basedOn to global default.

	CleanupStack::PushL(paraLayer);

	CCharFormatLayer* charLayer=CCharFormatLayer::NewL();  // Creates empty layer.

	charLayer->SetBase(aGlobalCharLayer);  // Sets basedOn to global default.

	CleanupStack::PushL(charLayer);

	CParaAttribs* paraAttribs=GetParaAttribsL(paraLayer,charLayer);

	CleanupStack::PopAndDestroy(2);

	CleanupStack::PushL(TCleanupItem(ReleaseOnCleanup,paraAttribs));

	iParaIx=new(ELeave) CArrayFixSeg<TParaAttribsEntry>(aParaGran);

	TParaAttribsEntry para(1,paraAttribs);

	iParaIx->AppendL(para);

	CleanupStack::Pop();

	iPhraseIx=new(ELeave) CArrayFixSeg<RPhraseAttribsEntry>(aPhraseGran);

	__TEST_INVARIANT;

	}

CRichTextIndex::~CRichTextIndex()

// Free up all storage allocated in the rich text index.

//

	{

	TInt count;

	if (iPhraseIx)

		{// Destroy the phrase index and its contents.

		if (!iParaIx)

		    {

		    OstTrace0( TRACE_FATAL, CRICHTEXTINDEX_CRICHTEXTINDEX, "EPhraseIxPresentWithNoParaIx" );

		    }

		__ASSERT_ALWAYS(iParaIx,Panic(EPhraseIxPresentWithNoParaIx));

		count=iPhraseIx->Count();

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

			(*iPhraseIx)[offset].Discard();

		}

	delete iPhraseIx;

	if (iParaIx)

		{// Destroy the para index and its contents.

		count=iParaIx->Count();

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

			{

			CParaAttribs* pA=(*iParaIx)[offset].iParaAttribs;

			if (!pA->IsShared())

				pA->Release();

			}

		}

	delete iParaIx;

	RebalanceIndex();

	//

	// Clear the shared list.  (Will usually be empty by now

	// unless internalize failed after getting shared list & before getting all para data.

	CParaAttribs* currentSharedPara;

	TDblQueIter<CParaAttribs> iterator(iSharedParaQueHead);

	while ((currentSharedPara=iterator++)!=NULL)

		currentSharedPara->Release(currentSharedPara->iRefCount);

	if (!iSharedParaQueHead.IsEmpty())

	    {

	    OstTrace0( TRACE_FATAL, DUP1_CRICHTEXTINDEX_CRICHTEXTINDEX, "ERichTextIndexIntegrityErr" );

	    }

	__ASSERT_ALWAYS(iSharedParaQueHead.IsEmpty(),Panic(ERichTextIndexIntegrityErr));

	}

TInt CRichTextIndex::CharPosOfParagraph(TInt& aLength,TInt aParaOffset)const

// Returns the character position of the first character of paragraph aParaOffset,

// where aParaOffset specifies the nth paragraph.

// The length of this nth paragraph is written to aLength.

//

// If aParaOffset specifies a paragraph that does not exist, EScanEndOfData is returned.

//

	{

	__TEST_INVARIANT;

	if (aParaOffset>=iParaIx->Count())

		return CPlainText::EScanEndOfData;

	TInt pos=0,offset=0;

	for (offset=0;offset<aParaOffset;offset++)

		pos+=(*iParaIx)[offset].iLength;

	aLength=(*iParaIx)[offset].iLength;

	return pos;

	}

TInt CRichTextIndex::ParagraphNumberForPos(TInt& aPos)const

// Returns the paragraph offset for the specified character position aPos.

// aPos is in turn modified to hold the character position of the first character

// of this paragraph.  If aPos is already on a paragraph boundary then do nothing.

//

	{

	__TEST_INVARIANT;

	((CRichTextIndex*)this)->ScanToPosition(aPos,EScanToPositionAbsolute);

	aPos-=iPos.iParaElementOffset;

	return iPos.iParaElement;

	}

void CRichTextIndex::DocumentChanged()const

	{

 	MUTABLE_CAST(TLogicalPosition&,iLastUsed).Clear();

	}

void CRichTextIndex::DoSoloInsertL(TInt aPos,TInt aLength)

// Updates the index following the insertion of content into a single phrase.

// First find the phrase record the governs the insert pos.

// (1) If the current phrase is a text phrase, then simply extend the length of the phrase record.

// (2) If the current phrase is a picture phrase then this cannot be extended.

// There is 1 pathological case here:

// (i) The [current] picture phrase is the 1st phrase in the paragraph, and the insert pos

// is before this phrase. (paragraph insert pos == 0).

// In this case we must insert a new text phrase *before* the picture phrase.

// (ii) In normal circumstances the inserted text is after the picture phrase.  So, if the

// following phrase is of the same character format as the picture then we can re-use this phrase.

// If it is not of the same character format (or is also a picture phrase),

// then we must insert a new text phrase of the correct format immediately following the current picture phrase.

//

	{

	RebalanceIndex();

	if (!((iPendingNewPhrasePos == EInsertCharFormatReset) || (aPos == iPendingNewPhrasePos)))

		CancelInsertCharFormat();

	ScanToPosition(aPos,EScanToPositionMatchLeft);

	TCurrentIndexRecords current; GetCurrentRecords(current);

	if (current.iPhrase && current.iPhrase->IsPicturePhrase())

		{// Paragraph has specific char format, and current phrase is picture phrase.

		TInt newPhraseRequired=EFalse;

		CCharFormatLayer* charLayer=current.iPhrase->CharFormat();

		if (FirstPhraseOfParagraph() && iPos.iPhraseElementOffset==0)

			newPhraseRequired=ETrue;  // Text is inserted at the start of the para behind the picture.

		else

			{// Check for re-use of the next text phrase.

			iPos.iPhraseElement++;

			iPos.iPhraseElementOffset=0;

			const RPhraseAttribsEntry& nextPhrase=(*iPhraseIx)[iPos.iPhraseElement];

			if (nextPhrase.IsPicturePhrase() || !nextPhrase.CharFormat()->IsIdentical(charLayer,EFalse))

				{// Need a new phrase if the formats don't match OR the next phrase is a picture phrase.

				newPhraseRequired=ETrue;  // Need to create a new phrase to take this insert.

				}

			}

		if (newPhraseRequired)

			{// Insert new phrase & record this fact

			CCharFormatLayer* charFormat=CCharFormatLayer::NewCopyBaseL(charLayer);

			RPhraseAttribsEntry newPhrase(charFormat);

			CleanupStack::PushL(charFormat);

			iPhraseIx->InsertL(iPos.iPhraseElement,newPhrase);

			CleanupStack::Pop();

			current.iParaAttribs->iPhraseCount++;

			}

		GetCurrentRecords(current);  // Update current records, cos used below.

		}

	// Extend the lengths in the index.

	current.iParaEntry->iLength+=aLength;  // Increase length of paragraph.

	if (current.iPhrase)

		current.iPhrase->AdjustLength(aLength);  // Increase the length of this phrase.

	iPos.iPhraseElementOffset+=aLength;

	iPos.iParaElementOffset+=aLength;

	iPos.iDocPos+=aLength;

	}

void CRichTextIndex::InsertL(TInt aPos,const TDesC& aBuf,const CParaFormatLayer& aGlobalParaFormatLayer)

// Updates the index following the insertion of a descriptor of text into the document.

// Correctly handles embedded paragraph delimiters.

//

	{

	__TEST_INVARIANT;

	TInt bufLen=aBuf.Length();

	RebalanceIndex();

	TInt paragraphCount=0;

	const TText* start=aBuf.Ptr();

	const TText* end=start+bufLen;

	while (start<end)

		{

		if (*start++==CEditableText::EParagraphDelimiter)

			paragraphCount++;

		}

	if (paragraphCount==0)

		{

		if (bufLen > 0)

			{

			DoSoloInsertL(aPos,bufLen);

			CancelInsertCharFormat();

			}

		__TEST_INVARIANT;

		return;

		}

	ScanToPosition(aPos,EScanToPositionMatchLeft);

	TLogicalPosition pastePos=iPos;  // Used to adjust paragraph/phrase lengths later

	if (paragraphCount>1)

		{

		TCurrentIndexRecords current;

		GetCurrentRecords(current);

		const CParaAttribs& paraAttribs=*current.iParaAttribs;

		CCharFormatLayer* charLayer=(paraAttribs.IsShared())

								? paraAttribs.iCharFormat

								: (*iPhraseIx)[iPos.iPhraseElement].CharFormat();

		CParaFormatLayer* paraLayer=paraAttribs.iParaFormat;

		CParaAttribs* theParaAttribs=GetParaAttribsL(paraLayer,charLayer);

		CleanupStack::PushL(TCleanupItem(ReleaseOnCleanup,theParaAttribs));

		iParaIx->InsertL(pastePos.iParaElement,TParaAttribsEntry(0,theParaAttribs),paragraphCount-1);

		CleanupStack::Pop();

		theParaAttribs->iRefCount+=paragraphCount-2;	// add the extra references

		}

	TLogicalPosition pos;

	TRAPD(ret,

	SplitParagraphAtPastePosL(pastePos,pos,aGlobalParaFormatLayer));

		if (ret!=KErrNone)

			{

			RbRemoveInsertedParaAttribsEntries(pastePos.iParaElement,paragraphCount-1);

			User::Leave(ret);

			}

	if (paragraphCount>1)

		{	// swap the entries for the split and first inserted paragraph

		TParaAttribsEntry& paraEntry=(*iParaIx)[pastePos.iParaElement+paragraphCount-1];

		TParaAttribsEntry& insertEntry=(*iParaIx)[pastePos.iParaElement];

		TParaAttribsEntry temp=paraEntry;

		paraEntry=insertEntry;

		insertEntry=temp;

		}// Cos weve inserted new paragraphs in front of the governing one.

	// Sort out the front para

	TParaAttribsEntry& frontPara=(*iParaIx)[pastePos.iParaElement];

	TPtrC buf(aBuf);

	TInt lengthOfFirstPara=ParaLengthFromBuffer(buf);

	frontPara.iLength+=lengthOfFirstPara;  // Adjust the para length

	buf.Set(aBuf.Right(aBuf.Length()-lengthOfFirstPara-1));

	if (!frontPara.iParaAttribs->IsShared() && lengthOfFirstPara != 0)

		{

		RPhraseAttribsEntry* phrase=&(*iPhraseIx)[pastePos.iPhraseElement];

		if (phrase->IsPicturePhrase())

			{	// move insertion past any picture phrase

			pastePos.iPhraseElement++;

			pastePos.iPhraseElementOffset=0;

			phrase=&(*iPhraseIx)[pastePos.iPhraseElement];

			}

		phrase->AdjustLength(lengthOfFirstPara);  // Adjust the phrase length

		}

	for (TInt paraItem=1;paraItem<paragraphCount;paraItem++)

		{// For each para inserted between the fist and last

		TParaAttribsEntry& para=(*iParaIx)[pastePos.iParaElement+paraItem];

		TInt length=ParaLengthFromBuffer(buf)+1;

		if (length==KErrNotFound)

		    {

		    OstTrace0( TRACE_DUMP, CRICHTEXTINDEX_INSERTL, "EInsertEmbeddedParaErr" );

		    }

		__ASSERT_DEBUG(length!=KErrNotFound,Panic(EInsertEmbeddedParaErr));

		para.iLength=length;

		buf.Set(buf.Right(buf.Length()-length));

		}

	// For final paragrph

	TInt trailingTextLen=buf.Length();

	if (trailingTextLen>0)

		{

		TParaAttribsEntry& backPara=(*iParaIx)[pos.iParaElement];

		backPara.iLength+=trailingTextLen;

		if (!backPara.iParaAttribs->IsShared())

			{

			RPhraseAttribsEntry& phrase=(*iPhraseIx)[pos.iPhraseElement];

			phrase.AdjustLength(trailingTextLen);  // Adjust phrase length

			}

		}

	//

	// Now tidy up

	if (bufLen>1 && iPendingNewPhrasePos!=EInsertCharFormatReset)

		{

		iPendingNewPhrasePos=aPos+(bufLen-trailingTextLen);

		CancelInsertCharFormat();

		}

	__TEST_INVARIANT;

	}

void CRichTextIndex::SplitParagraphAtPastePosL(TLogicalPosition& aPastePos,TLogicalPosition& aNewPos,

												const CParaFormatLayer& aGlobalParaFormatLayer)

// Breaks the paragraph specified by the logical position aPastePos, inserting a paragraph delimiter.

//

	{

	TInt insertPendingPos = iPendingNewPhrasePos;

	DoSoloInsertL(aPastePos.iDocPos,1);

	TBool insertCharFormatDeleted = EFalse;

	if (InsertCharFormatIsActive())

		{

		insertCharFormatDeleted = DeleteInsertCharFormat();

		iPendingNewPhrasePos = EInsertCharFormatReset;

		}

	TRAPD(ret,

	InsertParagraphL(aPastePos.iDocPos+1,aGlobalParaFormatLayer));  // Split the current para (and maybe phrase index).

	if (ret!=KErrNone)

		{

		// locate the character inserted by DoSoloInsertL() above

		ScanToPosition(aPastePos.iDocPos,EScanToPositionAbsolute);

		TCurrentIndexRecords current;

		GetCurrentRecords(current);

		current.iParaEntry->iLength--;

		if (current.iPhrase)

			{

			current.iPhrase->AdjustLength(-1);  // collapse phrase by right amount

			if (insertPendingPos!=EInsertCharFormatReset)

				{

				if (current.iPhrase->Length()!=0)

				    {

				    OstTrace0( TRACE_DUMP, CRICHTEXTINDEX_SPLITPARAGRAPHATPASTEPOSL, "Invariant" );

				    }

				__ASSERT_DEBUG(current.iPhrase->Length()==0,User::Invariant());

				iPendingNewPhrasePos=insertPendingPos;

				}

			else if (current.iPhrase->Length()==0)

				{

				RemoveFromPhraseIx(iPos.iPhraseElement,1);

				current.iParaAttribs->iPhraseCount--;

				if (current.iParaAttribs->PhraseCount()<=1)

				    {

				    OstTrace0( TRACE_DUMP, DUP1_CRICHTEXTINDEX_SPLITPARAGRAPHATPASTEPOSL, "Invariant" );

				    }

				__ASSERT_DEBUG(current.iParaAttribs->PhraseCount()>1,User::Invariant());

				}

			}

		OstTrace1( TRACE_DUMP, DUP2_CRICHTEXTINDEX_SPLITPARAGRAPHATPASTEPOSL, "Leave code=%d", ret );

		User::Leave(ret);

		}

	if (insertPendingPos != EInsertCharFormatReset)

		ConsolidateAt(insertPendingPos, insertCharFormatDeleted?

			EPositionOnly : EFollowingPhrase);

	ScanToPosition(aPastePos.iDocPos+1,EScanToPositionMatchLeft);  // Gives us the next para.

	aNewPos=iPos;

	}

TInt CRichTextIndex::ParaLengthFromBuffer(TDesC& aBuf)const

// Returns the length of the first para found in the buffer.

// The returned length excludes the paragraph delimiter character.

// Returns KNotFound if there is no paragraph delimiter.

//

	{return aBuf.Locate(CEditableText::EParagraphDelimiter);}

void CRichTextIndex::InsertL(TInt aPos,const TPictureHeader& aPicHdr, TBool& aPictureOwnershipTaken)

// Updates the index following the insertion of a picture header object into the text

// component.  This is accomplished by creating & inserting a picture phrase at the

// relevant place.

//

	{

	__TEST_INVARIANT;

	RebalanceIndex();

// ASSERT: A valid picture header, referencing a valid picture has been inserted.

	if (!aPicHdr.iPicture.IsPtr() || aPicHdr.iPicture.AsPtr()==NULL)

	    {

	    OstTrace0( TRACE_FATAL, DUP1_CRICHTEXTINDEX_INSERTL, "EInsertNullPicHdrData" );

	    }

	__ASSERT_ALWAYS(aPicHdr.iPicture.IsPtr() && aPicHdr.iPicture.AsPtr()!=NULL,Panic(EInsertNullPicHdrData));

// ASSERT: The current insert pos hasn't been changed without cancelling SetInsertCharFormat.

	if ((iPendingNewPhrasePos!=EInsertCharFormatReset) && (aPos!=iPendingNewPhrasePos))

	    {

	    OstTrace0( TRACE_FATAL, DUP2_CRICHTEXTINDEX_INSERTL, "ESetInsertCharFormatIntegrityErr" );

	    }

	__ASSERT_ALWAYS((iPendingNewPhrasePos==EInsertCharFormatReset) || (aPos==iPendingNewPhrasePos),

					Panic(ESetInsertCharFormatIntegrityErr));

	if (iPendingNewPhrasePos!=EInsertCharFormatReset)

		CancelInsertCharFormat();  // Cancel this state before inserting picture. Rebalances the index.

	ScanToPosition(aPos,EScanToPositionMatchLeft);

	TCurrentIndexRecords current; GetCurrentRecords(current);

	TCharFormatX format;

	TCharFormatXMask mask;  //...and build up its format.

	CCharFormatLayer* baseChar;

	GetPhraseFormat(current,format,mask,baseChar);  //...inherit format from prev. phrase.

	// Create the picture phrase. Takes ownership of the aPicHdr.iPicture

	CPicturePhrase* picture=CPicturePhrase::NewL(aPicHdr,format,mask,baseChar,aPictureOwnershipTaken);

	CleanupStack::PushL(picture);

	//New reclaimed CParaAttribs instance

	CParaAttribs* reclaimed=RequestReclaimShareL(current.iParaAttribs,current.iParaEntry);

    //Store the old CParaAttribs instance in rollbackParaAttribsHandle

	CParaAttribs* rollbackParaAttribsHandle=current.iParaAttribs;

	if (reclaimed)

		{

		CleanupStack::PushL(TCleanupItem(ReleaseOnCleanup,reclaimed));

		current.iParaEntry->iParaAttribs=reclaimed;  // Use this reclaimed para attribs (the new CParaAttribs instance)

		}

	GetCurrentRecords(current);

//	ASSERT: The reclaim succeeded.  We must always end up with a PhraseIx-not constant char format.

	if (current.iPhrase==NULL)

	    {

	    OstTrace0( TRACE_DUMP, DUP3_CRICHTEXTINDEX_INSERTL, "EReclaimShareError" );

	    }

	__ASSERT_DEBUG(current.iPhrase!=NULL,Panic(EReclaimShareError));

	TRAPD(ret1,

	SplitPhraseL(aPos));  // Phrase may not be split if at boundary.

    if (ret1!=KErrNone)

        {

        RbInsertPicture(rollbackParaAttribsHandle);//Restore the old CParaAttribs instance

        User::Leave(ret1);

        }

	TInt offset=(PhraseSplit())?1:0;  // Insert position of new phrase relative to current.

	RPhraseAttribsEntry newPhrase(picture);

	TRAPD(ret2,

	iPhraseIx->InsertL(iPos.iPhraseElement+offset,newPhrase));

    if (ret2!=KErrNone)

        {

        RbInsertPicture(rollbackParaAttribsHandle);//Restore the old CParaAttribs instance

        User::Leave(ret2);

        }

	if(reclaimed)

	    {

        CleanupStack::Pop();//"Pop" for CleanupStack::PushL(TCleanupItem(ReleaseOnCleanup,reclaimed));

	    }

	CleanupStack::Pop(picture);

	// Update counts etc. - cannot leave now.

	current.iParaEntry->iLength+=RPhraseAttribsEntry::EPicturePhraseLength;

	current.iParaAttribs->iPhraseCount++;  // for the picture phrase

	iPictureCount++;

	// Commit

	if(reclaimed)

	    {

        rollbackParaAttribsHandle->Release();  // Release hold on original shared paraAttribs.

	    }

	__TEST_INVARIANT;

	//coverity[memory_leak]

	}

void CRichTextIndex::RbInsertPicture(CParaAttribs* aGoodParaAttribs)

// Reinstate the original good paraAttribs.

// Then rollback the SplitPhrase() call if it succeeded.

//

	{

	(*iParaIx)[iPos.iParaElement].iParaAttribs=aGoodParaAttribs;

	if (PhraseSplit())

		{// Rollback the SplitPhrase()

		TInt length=(*iPhraseIx)[iPos.iPhraseElement+1].Length();

		RemoveFromPhraseIx(iPos.iPhraseElement+1);

		(*iPhraseIx)[iPos.iPhraseElement].AdjustLength(length);

		}

	}

// Insert a new paragraph immediately following character position aPos, fixing the length of the preceeding

// paragraph.  The new paragraph preserves any explicit paragraph/character formatting, and is based on the

// global layers.  (Do not need to rebalance the index here; a previous call to DoSoloInsertL accomplishes this)

void CRichTextIndex::InsertParagraphL(TInt aPos,const CParaFormatLayer& aGlobalParaFormatLayer)

	{

	ScanToPosition(aPos,EScanToPositionMatchLeft);

	TCurrentIndexRecords current;

	GetCurrentRecords(current);

	TParaAttribsEntry newPara;

	CCharFormatLayer* charLayer;

  	if (current.iPhrase)  // entry in phrase index

		charLayer=current.iPhrase->CharFormat();

	else

		charLayer=current.iParaAttribs->iCharFormat;

	//

	// New para format layer, based on normal, inheriting specific format

	CParaFormatLayer* currentParaFormat=current.iParaAttribs->iParaFormat;

	CParaFormatLayer* newParaLayer=CParaFormatLayer::NewL(currentParaFormat);

	const CParaFormatLayer& currentStyle=STATIC_CAST(const CParaFormatLayer&,*currentParaFormat->SenseBase());

	const TUid currentStyleType=currentStyle.Type();

	// !!

	// Only change to Normal if current style is a built-in one

	// or we are not at the end of a heading style.

	TBool useNormal;

	if (currentStyleType==KNormalParagraphStyleUid)

		useNormal=ETrue;

	else if (currentStyleType==KUserDefinedParagraphStyleUid)

		useNormal=EFalse;

	else if (iPos.iParaElementOffset<=(current.iParaEntry->iLength-2))  // cos of previous call to DoSoloInsertL()

		useNormal=EFalse;

	else

		useNormal=ETrue;

	newParaLayer->SetBase((useNormal)

		? &aGlobalParaFormatLayer

		: &currentStyle);

	const CCharFormatLayer* newCharBase=(useNormal)

		? iText.GlobalCharFormatLayer()

		: STATIC_CAST(const CParagraphStyle&,currentStyle).CharFormatLayer();

	CleanupStack::PushL(newParaLayer);

	//

	if (current.iParaAttribs->IsShared())

		{// Current para has constant char format - so the new one also has constant char format

		// New char format layer, based on normal, inheriting specific format

		CCharFormatLayer* newCharLayer=CCharFormatLayer::NewL(charLayer);

		newCharLayer->SetBase(newCharBase);

		CleanupStack::PushL(newCharLayer);

		newPara.iParaAttribs=GetParaAttribsL(newParaLayer,newCharLayer);

		CleanupStack::PopAndDestroy(2);  // newCharLayer/newParaLayer

		CleanupStack::PushL(TCleanupItem(ReleaseOnCleanup,newPara.iParaAttribs));

		iParaIx->InsertL(iPos.iParaElement+1,newPara);

		CleanupStack::Pop();  // paraAttribs cleanup item

		GetCurrentRecords(current);		// could be changed by InsertL() above

		}

	else  // Do the split myself since this para has specific character formatting.

		{// Make the new CParaAttribs

		CParaAttribs* newParaAttribs=CParaAttribs::NewL(newParaLayer);

		CleanupStack::PopAndDestroy();  // newParaLayer - copy owned by newParaAttribs

		CleanupStack::PushL(TCleanupItem(ReleaseOnCleanup,newParaAttribs));

		//

		// Split current phrase & insert if necessary.

		// Split even when we are at a phrase boundary -> this introduces an z.l.p. for the insertion point

		RPhraseAttribsEntry& insertPhrase=iPhraseIx->At(iPos.iPhraseElement);

		TInt insertPendingPos=(iPos.iPhraseElementOffset==insertPhrase.Length()) ? aPos : EInsertCharFormatReset;

		DoSplitPhraseL(insertPhrase,iPos.iPhraseElementOffset,current.iParaAttribs);  // Ups iPhraseCount

		//

		// Insert the new paragraph.

		newPara.iParaAttribs=newParaAttribs;

		TRAPD(ret,

		iParaIx->InsertL(iPos.iParaElement+1,newPara));  // Inserts the new paraAttribsEntry record.

			if (ret!=KErrNone)

				{

				RemoveFromPhraseIx(iPos.iPhraseElement+1,1);	// inserted by DoSplitPhraseL

				current.iParaAttribs->iPhraseCount--;

				User::Leave(ret);

				}

		iPendingNewPhrasePos=insertPendingPos;

		CleanupStack::Pop();			// newParaAttribs. All OK now

		GetCurrentRecords(current);		// could be changed by InsertL() above

		//

		// Calculate new paraAttribs phrase counts.

		TInt remainder=(iPos.iPhraseElement+1)-iPos.iParaBasePhraseElement;

		TInt newPhraseCount=current.iParaAttribs->iPhraseCount-remainder;

		newParaAttribs->iPhraseCount=newPhraseCount;

		current.iParaAttribs->iPhraseCount=remainder;

		const CArrayFix<RPhraseAttribsEntry>& phraseIx=*iPhraseIx;

		TInt startPhrase=iPos.iPhraseElement+1;

		for (TInt ii=startPhrase; ii<startPhrase+newPhraseCount; ii++)

			{

			RPhraseAttribsEntry phrase=phraseIx[ii];

			phrase.CharFormat()->SetBase(newCharBase);

			}

		//

		// The index now reflects the correct state.

		// Next, the efficiency thing - see if the new paras can share existing ones.

		if (newPhraseCount==1)

			Share(iParaIx->At(iPos.iParaElement+1),iPos.iParaBasePhraseElement+remainder);

		if (remainder==1)

			Share(iParaIx->At(iPos.iParaElement),iPos.iParaBasePhraseElement);

		}

	// Alter the length of the original paragraph and the new paragraph.

	TInt currentLength=current.iParaEntry->iLength;

	current.iParaEntry->iLength=iPos.iParaElementOffset;

	((*iParaIx)[iPos.iParaElement+1]).iLength+=currentLength-current.iParaEntry->iLength;  // Alters the length of the copy of aNewPara.

	}

void CRichTextIndex::SetForDeleteL(TIndexDeleteInfo& aInfo,TInt aPos,TInt aLength)

//

	{

	__TEST_INVARIANT;  // Do not need to RebalanceIndex(); part of defined behaviour for delete.

	aInfo.iDeleteLength=aLength;

	//

	// Check for simple cases first

	DocumentChanged();  // clears internal position record.

	ScanToPosition(aPos,EScanToPositionAbsolute,&iLastUsed);

	TCurrentIndexRecords current;

	GetCurrentRecords(current);

	aInfo.iStartPara=iPos.iParaElement;

	aInfo.iEndPara=iPos.iParaElement;  // default

	aInfo.iDeletePos=iPos;  // default

	//

	TInt startParaLength=current.iParaEntry->iLength;

	TInt lengthRemainingInPara=startParaLength-iPos.iParaElementOffset;

	if (aLength<lengthRemainingInPara)

		{// Case is delete-from-paragraph

		aInfo.iDeleteType=TIndexDeleteInfo::EDeleteFromParagraph;

		return;

		}

	//

	ScanToPosition(aPos+aLength,EScanToPositionMatchLeft,&iLastUsed);  // Forces endPara to be next para when just removing a para delimiter.

	aInfo.iEndPara=iPos.iParaElement;

//	if (iPos.iParaElementOffset==0)

//		{// Can use delete-paragraph

//		aInfo.iDeleteType=TIndexDeleteInfo::EDeleteParagraph;

//		return;

//		}

	//

	// Set for the general (leaving) delete.

	GetCurrentRecords(current);

	CParaAttribs* reclaimedEndPara=RequestReclaimShareL(current.iParaAttribs,current.iParaEntry); // does not release share.

	TParaAttribsEntry* origEndParaEntry=current.iParaEntry;

	CParaAttribs* origParaAttribs=current.iParaAttribs;

	TInt endPosPhrase=iPos.iPhraseElement;

	if (reclaimedEndPara)

		origEndParaEntry->iParaAttribs=reclaimedEndPara;

	// Get start para info.

	ScanToPosition(aPos,EScanToPositionAbsolute);

	GetCurrentRecords(current);

	CParaAttribs* reclaimedStartPara=NULL;

	TRAPD(ret,

	reclaimedStartPara=RequestReclaimShareL(current.iParaAttribs,current.iParaEntry));

		if (ret!=KErrNone)

			{

			if (reclaimedEndPara)

				{

				reclaimedEndPara->Release();

				RemoveFromPhraseIx(endPosPhrase);

				origEndParaEntry->iParaAttribs=origParaAttribs;

				}

			User::Leave(ret);

			}

	if (reclaimedEndPara)

		origParaAttribs->Release();  // Release share on the original end para attribs

	if (reclaimedStartPara)

		{// Use the specific start  para

		current.iParaAttribs->Release();

		current.iParaEntry->iParaAttribs=reclaimedStartPara;

		ScanToPosition(aPos,EScanToPositionAbsolute);  // Pick up reclaimed phrase.

		}

	aInfo.iDeletePos=iPos;  // internal position of aPos after any reclaim

	// Note: iDeleteType can surely be made obsolete now? TPB 7/11/2000

	aInfo.iDeleteType=TIndexDeleteInfo::EDeleteFromParagraph;

	/*

	 * Pointer to memory allocated to 'reclaimedEndPara' is assigned to 

	 * 'origEndParaEntry->iParaAttribs' on line 706. The memory will be 

	 * released in CRichTextIndex's destructor.

	 */ 

	// coverity[memory_leak]

	}

TBool CRichTextIndex::DeleteParagraph(TInt aPos,TInt aLength)

// Remove aCount entire paragraphs from the text.

// Leave-safe

// Returns EFalse indicating that no paragraphs were merged together,

// as a result of the delete action.

// Does NOT preserve any zero-length/insert pending state.

//

	{

	__TEST_INVARIANT;  // Do not need to RebalanceIndex(); part of defined behaviour for delete.

	CancelInsertCharFormat();

	ScanToPosition(aPos,EScanToPositionAbsolute,&iLastUsed);

	if (iPos.iParaElementOffset!=0)

	    {

	    OstTrace0( TRACE_DUMP, CRICHTEXTINDEX_DELETEPARAGRAPH, "EDeleteParagraphInvalidStartValue" );

	    }

	__ASSERT_DEBUG(iPos.iParaElementOffset==0,Panic(EDeleteParagraphInvalidStartValue));

	TIndexDeleteInfo info;

	info.iDeleteType=TIndexDeleteInfo::EDeleteParagraph;

	info.iDeletePos=iPos;

	info.iStartPara=iPos.iParaElement;

	//

	TInt documentLength=iText.DocumentLength();

	TInt pos=(aPos+aLength>documentLength

		? documentLength

		: aPos+aLength);

	ScanToPosition(pos,EScanToPositionMatchLeft,&iLastUsed);  // Forces endPara to be next para when just removing a para delimiter.

	info.iEndPara=iPos.iParaElement;

	info.iDeleteLength=aLength;

	DeleteNow(info);

	// do not want to call TidyAfterDelete()

	return EFalse;

	}

void CRichTextIndex::DeleteFromParagraph(TInt aPos,TInt aLength)

// Special case delete for removing content from within a single paragraph only.

// Not to be used for deleting an entire paragraph or paragraphs.

// Returns EFalse indicating that no paragraphs were merged together,

// as a result of the delete action.

//

	{

	__TEST_INVARIANT;  // Do not need to RebalanceIndex(); part of defined behaviour for delete.

	ScanToPosition(aPos,EScanToPositionAbsolute);

#ifdef _DEBUG

	{

	TCurrentIndexRecords current;

	GetCurrentRecords(current);

	TInt startParaLength=current.iParaEntry->iLength;

	TInt lengthRemainingInPara=startParaLength-iPos.iParaElementOffset;

	if (aLength>=lengthRemainingInPara)

	    {

	    OstTrace0( TRACE_FATAL, CRICHTEXTINDEX_DELETEFROMPARAGRAPH, "EDeleteFromParagraphInvalidRange" );

	    }

	__ASSERT_ALWAYS(aLength<lengthRemainingInPara,Panic(EDeleteFromParagraphInvalidRange));

	}

#endif

	TIndexDeleteInfo info;

	info.iDeleteLength=aLength;

	info.iStartPara=iPos.iParaElement;

	info.iEndPara=iPos.iParaElement;

	info.iDeletePos=iPos;

	info.iDeleteType=TIndexDeleteInfo::EDeleteFromParagraph;

	DoDeleteFromParagraph(info);

	__TEST_INVARIANT;

	}

TBool CRichTextIndex::DoDeleteFromParagraph(const TIndexDeleteInfo& aInfo)

// Delete content from *within* the boundary of a single paragraph only.0

// Returns EFalse indicating that no paragraphs were merged together,

// as a result of the delete action.

//

	{

	iPos=aInfo.iDeletePos;

	TInt length=aInfo.iDeleteLength;

	DeleteParagraphText(length);

	TidyAfterDelete(aInfo);

	return EFalse;

	}

TBool CRichTextIndex::DeleteNow(TIndexDeleteInfo& aInfo)

// Deletes index data corresponding the info argument.

// Returns ETrue is 2 paragraphs are merged as a result of the delete, otherwise returns false.

//

	{

	iPos=aInfo.iDeletePos;

	TCurrentIndexRecords current;

	GetCurrentRecords(current);

	TInt leftToDelete=aInfo.iDeleteLength;

	TInt charsLeftInPara=(current.iParaEntry->iLength)-(iPos.iParaElementOffset);

	TBool doParaMerge=((iPos.iPhraseElement>0 || iPos.iPhraseElementOffset>0) && leftToDelete>=charsLeftInPara);

	// ETrue if the 1st para has content remaining but no paragraph delimiter.

	//

	TBool firstParaRemoved=(FirstPhraseOfParagraph() && iPos.iPhraseElementOffset==0 && aInfo.iDeleteLength>=current.iParaEntry->iLength);

	// ETrue if the 1st para has been *wholly* deleted.

	//

	DeleteParagraphText(leftToDelete);  // Delete range will be in a minimum of 1 paragraph.

	if (aInfo.iStartPara<aInfo.iEndPara)

		{// The delete range crosses paragraph boundaries.

		for (TInt currentPara=aInfo.iStartPara+1;currentPara<=aInfo.iEndPara;currentPara++)

			{

			ScanToPosition(aInfo.iDeletePos.iDocPos,EScanToPositionAbsolute);

			DeleteParagraphText(leftToDelete);

			}

		}

	// Now tidy up

	if (doParaMerge && !firstParaRemoved)

		{// Merge the 2 paras together.

		TParaAttribsEntry* paraEntry=&(*iParaIx)[aInfo.iStartPara];

		TParaAttribsEntry* paraEntryFollowing=&(*iParaIx)[aInfo.iStartPara+1];

		paraEntryFollowing->iLength+=paraEntry->iLength;  // Extend length of remaining para.

		paraEntryFollowing->iParaAttribs->iPhraseCount+=paraEntry->iParaAttribs->iPhraseCount;  // Extend phrase count

		paraEntry->iParaAttribs->Release();

		iParaIx->Delete(aInfo.iStartPara);

		}

	if (aInfo.iDeleteType!=TIndexDeleteInfo::EDeleteParagraph)

		TidyAfterDelete(aInfo);

	__TEST_INVARIANT;

	return doParaMerge;

	}

void CRichTextIndex::TidyAfterDelete(const TIndexDeleteInfo& aInfo)

//

//

	{

	MergePhrases(aInfo.iDeletePos.iDocPos);  // Alters internal position record.

	TCurrentIndexRecords current;

	GetCurrentRecords(current);  // So must get records again.

	if (!current.iParaAttribs->IsShared())

		{// May be able to reclaim a share from this *specific* record

		CParaAttribs* sharedParaAttribs=RequestShare(iPos);

		if (sharedParaAttribs!=NULL && current.iParaAttribs!=sharedParaAttribs)

			{// Use this shared record

			current.iParaAttribs->Release();

			RemoveFromPhraseIx(iPos.iPhraseElement);

			current.iParaEntry->iParaAttribs=sharedParaAttribs;

			}

		}

	}