/*

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

#include "TXTMRTSR.H"

#include "TXTRICH.H"

#include "TXTINDEX.H"

#include "TXTSTD.H"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "TXTFMLYR_INTERNAL.H"

#endif

const TUint8 KRegisterItemPresent=1;

GLDEF_C void DiscardPhraseOnCleanup(TAny* aPhrase)

// Allows RPhraseAttribsEntry on the CleanupStack to be destroyed correctly,

// when included as a PushL(TCleanupItem).

//

	{

	((RPhraseAttribsEntry*)aPhrase)->Discard();

	User::Free(aPhrase);

	}

TRtPasteContext::TRtPasteContext(const CStreamStore* aStore,const CParaFormatLayer* aGlobalParaLayer,const CCharFormatLayer* aGlobalCharLayer,const CStyleList* aStyleList)

//

	:iStore(aStore),

	iGlobalParaLayer(aGlobalParaLayer),iGlobalCharLayer(aGlobalCharLayer),iStyleList(aStyleList),

	iParagraphStylesFlag(EFalse),iIncompleteParaFlag(ETrue),iPastePos(),iParasPasted(0)

	{}

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

CRichTextIndex* CRichTextIndex::NewL(const CStreamStore& aStore,TStreamId aId,

//										MPictureFactory* aPictureFactory,MRichTextStoreResolver* aStoreResolver,

										const CParaFormatLayer* aGlobalParaLayer,

										const CCharFormatLayer* aGlobalCharLayer,

										const CRichText& aText)

//										const CStyleList* aStyleList)

//

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aGlobalParaLayer,aGlobalCharLayer,KMultiParaGranularity,KLargePhraseGranularity);

	self->RestoreL(aStore,aId,aGlobalParaLayer,aGlobalCharLayer,aText.StyleList());

//	self->SetPictureFactory(aPictureFactory,aStoreResolver);

	CleanupStack::Pop();

	return self;

	}

void CRichTextIndex::RestoreL(const CStreamStore& aStore,TStreamId aId,

									   const CParaFormatLayer* aGlobalParaLayer,

									   const CCharFormatLayer* aGlobalCharLayer,

									   const CStyleList* aStyleList)

//

	{

	RStoreReadStream stream;

	stream.OpenLC(aStore,aId);

	//

	InternalizeL(stream,aGlobalParaLayer,aGlobalCharLayer,aStyleList);

	CleanupStack::PopAndDestroy();  // stream

	}

TStreamId CRichTextIndex::StoreMarkupL(CStreamStore& aStore,const CStyleList* /*aStyleList*/) const

// Store this rich text markup out-of-line along with its components.

//

	{

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

	StorePicturesL(aStore,*map);

//

	RStoreWriteStream stream(*map);

	TStreamId id=stream.CreateLC(aStore);

//	CONST_CAST(CRichTextIndex*,this)->iStyleList=CONST_CAST(CStyleList*,aStyleList);

	ExternalizeL(stream);

	stream.CommitL();

//

	map->Reset();

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

	return id;

	}

void CRichTextIndex::StorePicturesL(CStreamStore& aStore,CStoreMap& aMap) const

// Store any picture components in the specified store.

// Due to deferred loading, any pictures that are not in memory at this point are loaded,

// and then saved.

//

	{

	__TEST_INVARIANT;

	StorePicturesL(aStore,aMap,0,iText.DocumentLength()+1);

	}

void CRichTextIndex::StorePicturesL(CStreamStore& aStore,CStoreMap& aMap,TInt aPos,TInt aLength) const

// Store all picture components that are contained within the specified range (inclusive), in the store provided.

// Prior to storing the picture, its size is written to its picture header which is stored in-line in 

// the markup.

// Any pictures that are not in memory are now deleted, as a previous call to LoadAllPicturesNowL()

// should have been made.

// We are guaranteed that all pictures that are in memory are fully restored & detached from their store

//

	{

	__TEST_INVARIANT;

	if (iPictureCount==0)

		return;

	CONST_CAST(CRichTextIndex*,this)->DetachFromStoreL(CPicture::EDetachFull,aPos,aLength);	// ensure all pictures have been loaded

	TInt currentPos=aPos;

	DocumentChanged();  // reset the cache logical position

	while (currentPos<aPos+aLength)

		{// Store next picture & increment pos.

		CONST_CAST(CRichTextIndex*,this)->ScanToPosition(currentPos,EScanToPositionAbsolute,&MUTABLE_CAST(TLogicalPosition&,iLastUsed));

		TCurrentIndexRecords current;

		GetCurrentRecords(current);

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

			{

			RPhraseAttribsEntry& phrase=*current.iPhrase;

			TPictureHeader* hdr=phrase.PictureHeaderPtr();

			__ASSERT_DEBUG(hdr,Panic(ERichTextStorePictureIntegrityError));

			TBool pictureInMemory=(hdr->iPicture.IsPtr() && hdr->iPicture.AsPtr());

			if (pictureInMemory)

				{// Store the picture

				CPicture& picture=*hdr->iPicture;

				picture.GetSizeInTwips(hdr->iSize);  //  write picture size to picture header.

				TStreamId id=picture.StoreL(aStore);

				aMap.BindL(hdr->iPicture,id);

				}

			else

				{// Replace the picture phrase with a simple text equivalent.

				CCharFormatLayer* charLayer=phrase.ReleaseCharFormatLayerOwnership();

				phrase.Discard();  // destroy the redundant picture phrase

				RPhraseAttribsEntry newTextPhrase(charLayer,1);

				(*iPhraseIx)[iPos.iPhraseElement]=newTextPhrase;

				CONST_CAST(CRichTextIndex*,this)->iPictureCount--;  // the picture has now been removed

				// I do not bother tidying up the phrase index here,

				// since the benefit does not currently match the cost involved.

				//

				}

			}

		//

		// increment the current position to the *start* of the next phrase/paragraph

		TInt offsetIntoUnit=(current.iPhrase)?iPos.iPhraseElementOffset:iPos.iParaElementOffset;

		currentPos+=CurrentPhraseLength()-offsetIntoUnit;

		}

	}

void CRichTextIndex::DetachFromStoreL(CPicture::TDetach aDegree,TInt aPos,TInt aLength)

// Attempts to restore all pictures not already present in memory.

// A deep (door+document) or shallow (door only) restoration may occur, depending

// on the value of detach.

//

	{

	__TEST_INVARIANT;

	if (iPictureCount==0)

		return;

	DocumentChanged();  // reset the cache logical position

	TInt currentPos=aPos;

	while (currentPos<aPos+aLength)

		{

		CONST_CAST(CRichTextIndex*,this)->ScanToPosition(currentPos,EScanToPositionAbsolute,&iLastUsed);

		TCurrentIndexRecords current;

		GetCurrentRecords(current);

		if (current.iPhrase)

			{

			RPhraseAttribsEntry& phrase=*current.iPhrase;

			if (phrase.IsPicturePhrase())

				{

				TPictureHeader* hdr=phrase.PictureHeaderPtr();

				__ASSERT_DEBUG(hdr,Panic(ERichTextStorePictureIntegrityError));

				//

				if (hdr->iPicture.IsId())

					{

					TRAPD(r,

					phrase.PictureHandleL(iText.PictureFactory(),iText.StoreResolver(),iPos.iDocPos,MLayDoc::EForceLoadTrue));  // swizzles

					__ASSERT_DEBUG(r==KErrNone || hdr->iPicture.IsId(),Panic(ERichTextStorePictureIntegrityError));

					if (r==KErrNotSupported)  // we don't recognise the picture type

						{

						TInt offsetIntoUnit=(current.iPhrase)?iPos.iPhraseElementOffset:iPos.iParaElementOffset;

						currentPos+=CurrentPhraseLength()-offsetIntoUnit;

						continue;

						}

					User::LeaveIfError(r);

					}

				//

				// recurse the call to detach the picture from the store

				__ASSERT_DEBUG(hdr->iPicture.IsPtr(),Panic(ERichTextStorePictureIntegrityError));

				hdr->iPicture->DetachFromStoreL(aDegree);

				}

			}

		//

		// increment the current position to the *start* of the next phrase/paragraph

		TInt offsetIntoUnit=(current.iPhrase)?iPos.iPhraseElementOffset:iPos.iParaElementOffset;

		currentPos+=CurrentPhraseLength()-offsetIntoUnit;

		}

	__TEST_INVARIANT;

	}

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

void CRichTextIndex::ExternalizeL(RWriteStream& aStream)const

// Persist the current state of this object in the specified stream.

// Saved records include the terminating paragraph delimiter. 

//

//

	{

	__TEST_INVARIANT;

	CONST_CAST(CRichTextIndex*,this)->CancelInsertCharFormat();  // cancel any insert-pending state.

	TInt charCount=iText.DocumentLength()+1;  // includes the end of document character

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

	TLogicalPosition startPos=iPos;

	((CRichTextIndex*)this)->ScanToPosition(charCount-1,EScanToPositionMatchLeft);

	TLogicalPosition endPos=iPos;

	CStyleList* styleList=iText.StyleList();

	ExternalizeRtiHeaderL(aStream,endPos,styleList);

	ExternalizeSharedFormatsL(aStream,startPos,endPos,styleList);

	// DEF126934 begin: memory leak

	RPhraseAttribsEntry *pForRelease = ExternalizeParaIxL(aStream,startPos,endPos,styleList);

	if (pForRelease)

		delete pForRelease;

	// DEF126934 end

	ExternalizePhraseIxL(aStream);

	}

void CRichTextIndex::InternalizeL(RReadStream& aStream,const CParaFormatLayer* aGlobalParaLayer,const CCharFormatLayer* aGlobalCharLayer,const CStyleList* aStyleList)

// Load a rich text index.  Has construct semantics only!

// Restores this object from the specified stream.  As specific format layers are restored, they are based

// on the specified global format layers. 

//

	{

	__ASSERT_ALWAYS(iParaIx->Count()==1 && (*iParaIx)[0].iLength==1,Panic(ERtIndexInternalizeCalledOnNonEmptySource));

	TRtPasteContext context(NULL,aGlobalParaLayer,aGlobalCharLayer,aStyleList);

	InternalizeRtiHeaderL(aStream,context);

	InternalizeSharedFormatsL(aStream,context);

	InternalizeParaIxL(aStream,context);

	InternalizePhraseIxL(aStream,aGlobalCharLayer);

	if (context.iParagraphStylesFlag)

		GenerateAllPhraseLinksL();

	SetSpecificMarkupInternalized(ETrue);

	__TEST_INVARIANT;

	}

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

void CRichTextIndex::GenerateAllPhraseLinksL()

// Go through the index, and for each specific character format layer (shared or otherwise), regenerate

// the appropriate based-on link, (normal or style).

// 

	{

	TInt count=ParagraphCount();

	TInt phraseElement=0;

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

		{

		const CParaAttribs& paraAttribs=*(*iParaIx)[ii].iParaAttribs;

		const CParaFormatLayer* base=STATIC_CAST(const CParaFormatLayer*,paraAttribs.iParaFormat->SenseBase());

		TInt phraseCount=paraAttribs.PhraseCount();

		if (phraseCount==1)

			{

			// If the reference count is zero, iCharFormat cannot be valid, so the CParaAttribs object is corrupt.

			if (paraAttribs.iRefCount == 0)

				User::Leave(KErrCorrupt);

			GeneratePhraseLink(paraAttribs.iCharFormat,base);  // constant character formatting

			}

		else

			{

			 __ASSERT_DEBUG(phraseCount>1,Panic(EDebug));

			// If the phrase count is too great the CParaAttribs object is corrupt.

			if (phraseElement + phraseCount > iPhraseIx->Count())

				User::Leave(KErrCorrupt);

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

				GeneratePhraseLink((*iPhraseIx)[phraseElement+nn].CharFormat(),base);

			phraseElement+=phraseCount;

			}

		}

	}

void CRichTextIndex::GeneratePhraseLink(CCharFormatLayer* aPhraseCharFormatLayer,const CParaFormatLayer* aBase)

// Set the based on link for this character format layer appropriately.

// By default, all specific character format layers are based on the global default.

//

	{

	TUid type=aBase->Type();

	if (type!=KNormalParagraphStyleUid)

		aPhraseCharFormatLayer->SetBase(((CParagraphStyle*)aBase)->CharFormatLayer());

	}

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

void CRichTextIndex::CopyToStreamL(RWriteStream& aStream,TInt aPos,TInt aLength, TBool aCopyStyles)const

// Copies the markup corresponding to the specified rich text region to the specified write stream.

// aPos/aLength has already been validated in RichText

// Saved records can NOT include the terminating paragraph delimiter.

//

	{

	__TEST_INVARIANT;

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

	TLogicalPosition startPos=iPos;

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

	TLogicalPosition endPos=iPos;

	CStyleList* docStyleList = NULL;

	if (aCopyStyles)

		docStyleList = (CStyleList*)iText.StyleList();

	ExternalizeRtiHeaderL(aStream,endPos,docStyleList);

	if (docStyleList)

		ExternalizeReferencedStylesL(aStream,startPos,endPos);

	ExternalizeSharedFormatsL(aStream,startPos,endPos,docStyleList); 

	RPhraseAttribsEntry* virtualTrailingText=ExternalizeParaIxL(aStream,startPos,endPos,docStyleList);

	if (virtualTrailingText)

	    CleanupStack::PushL(virtualTrailingText);

	ExternalizePhraseIxL(aStream,startPos,endPos,virtualTrailingText);

	if (virtualTrailingText)

	    CleanupStack::PopAndDestroy(virtualTrailingText);

	}

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

void CRichTextIndex::ExternalizeRtiHeaderL(RWriteStream& aStream,const TLogicalPosition& aEnd,const CStyleList* aStyleList)const

// Stores index specific information.

//

	{

	TBool incompleteParaFlag=((*iParaIx)[aEnd.iParaElement].iLength>(aEnd.iParaElementOffset+1));

	aStream.WriteUint8L((TUint8)(aStyleList!=NULL));  // flags the presence of paragraph styles.

	aStream.WriteUint8L((TUint8)(incompleteParaFlag!=EFalse)); // the last para has no paragraph delimiter

	if(incompleteParaFlag)

		{//apply paragraph format to final text fragment if logical end is at document end

		aStream.WriteUint8L((TUint8)(aEnd.iDocPos+1 == iText.DocumentLength()));

		}

	}

void CRichTextIndex::InternalizeRtiHeaderL(RReadStream& aStream,TRtPasteContext& aContext)

// Load index specific information.

//

	{

	TUint8 flag=0;

	aStream>> flag;

	aContext.iParagraphStylesFlag=(TBool)flag;

	aStream>> flag;

	aContext.iIncompleteParaFlag=(TBool)flag;

	aContext.iApplyFormatToLastFlag=EFalse;

	if(aContext.iIncompleteParaFlag)

		{

		aStream>> flag;

		aContext.iApplyFormatToLastFlag=(TBool)flag;

		}

	}

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

void CRichTextIndex::ExternalizeReferencedStylesL(RWriteStream& aStream,const TLogicalPosition& aStart,

												  const TLogicalPosition& aEnd) const

// Write those styles that are referenced by the paragraphs in the range aStart to aEnd.

//

	{

	CStyleList* list = iText.StyleList();

	__ASSERT_DEBUG(list,Panic(EStyleClipboardIntegrityError));

	__ASSERT_DEBUG(aStart.iParaElement <= aEnd.iParaElement,Panic(EStyleClipboardIntegrityError));

	TUint8 numStyles = 0;

	if (list) 

		numStyles = (TUint8)list->Count();

	HBufC8* buf=HBufC8::NewL(numStyles);

	TPtr8 paraRegister=buf->Des();

	paraRegister.FillZ(numStyles);

	TInt refCount=MarkStyleRegister(paraRegister,aStart.iParaElement,aEnd.iParaElement);

	CleanupStack::PushL(buf);

	ExternalizeItemsPresentInStyleRegisterL(aStream,refCount,paraRegister);

	CleanupStack::PopAndDestroy();

	}

void CRichTextIndex::InternalizeSharedFormatsL(RReadStream& aStream, const TRtPasteContext& aContext)

// Restores the list of shared para attribs.

// All existing CParaAttribs on the shared list are removed.

// The reference counts are not restored, but modified dynamically as the para index is loaded.

//

	{

	iParaIx->Reset();  // stops paraIx referencing shared paraAttribs that are about to be released.

	CParaAttribs* currentSharedPara;

	TDblQueIter<CParaAttribs> iterator(iSharedParaQueHead);

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

		currentSharedPara->Release(currentSharedPara->iRefCount);

	TUint8 sharedParaCount = ReadTUint8CountL(aStream);

	for (TUint8 paraItem = 0; paraItem < sharedParaCount; paraItem++)

		{

		(void)aStream.ReadInt32L();  // consume the data.

		CParaFormatLayer* paraLayer = InternalizeParagraphFormatL(aStream, aContext);

		CleanupStack::PushL(paraLayer);

		CCharFormatLayer* charLayer = CCharFormatLayer::NewL(aStream);  // Does not restore based on link.

		charLayer->SetBase(aContext.iGlobalCharLayer);  // base on 'Normal' global char format

		CleanupStack::PushL(charLayer);

		CParaAttribs* paraAttribs = CParaAttribs::NewL(paraLayer, charLayer);

		CleanupStack::PopAndDestroy(2);

		paraAttribs->iRefCount = 0;  // Otherwise recalculating reference counts on internalization of paraIx will result in 1 too many.

		iSharedParaQueHead.AddLast(*paraAttribs);

		}

	}

void CRichTextIndex::ExternalizeSharedFormatsL(RWriteStream& aStream,const TLogicalPosition& aStart,const TLogicalPosition& aEnd,const CStyleList* aStyleList)const

// Persist those items in the shared list that are referenced by the paragraphs in the 

// range aStart para to aEnd para.

//

	{

	TUint8 sharedParaCount=SharedParaAttribsEntryCountL();

	// Some paras coverd, so take register

	HBufC8* buf=HBufC8::NewL(sharedParaCount);

	TPtr8 sharedAttribsRegister=buf->Des();

	sharedAttribsRegister.FillZ(sharedParaCount);

	TInt sharedCount=MarkRegister(sharedAttribsRegister,aStart.iParaElement,aEnd.iParaElement);

	CleanupStack::PushL(buf);

	ExternalizeItemsPresentInRegisterL(aStream,sharedCount,sharedAttribsRegister,aStyleList);

	CleanupStack::PopAndDestroy();

	}

TUint8 CRichTextIndex::SharedParaAttribsEntryCountL()const

// Return a count of the number of items currently

// in the sharedParaFormats list.

//

// This will leave if more than 255 found, as this is not supported

	{

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

	TUint16 sharedParaCount = 0;

	while (iterator++ != NULL)

		sharedParaCount++;

	// Currently more than 255 paragraph formats are not supported 

	// If the current document has more, leave with KErrNotSupported

	if (sharedParaCount > 255)

		User::Leave(KErrNotSupported);

	return (TUint8)sharedParaCount;

	}

TInt CRichTextIndex::MarkRegister(TDes8& aBuf,TInt aStartPara,TInt aEndPara)const

// Indicate in the register, aBuf, once and once only, each paraAttribs that is

// referenced by each of the paragraphs in the specified range.

// Return the number of shared para formats referenced.

//