/*

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

#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());

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

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

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

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

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

				}

			}

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

		}

// ASSERT: 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

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

		}

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

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

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

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

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

				{

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

				iPendingNewPhrasePos=insertPendingPos;

				}

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

				{

				RemoveFromPhraseIx(iPos.iPhraseElement,1);

				current.iParaAttribs->iPhraseCount--;

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

				}

			}

		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.

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

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

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

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

        }