/*

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

 #include "TXTSTYLE.H"

 #include "TXTFRMAT.H"

 #include "TXTSTD.H"

 #include "OstTraceDefinitions.h"

 #ifdef OST_TRACE_COMPILER_IN_USE

 #include "TXTSTYLETraces.h"

 #endif

 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

 #include "TXTFMLYR_INTERNAL.H"

 #include "TXTSTYLE_INTERNAL.H"

 #endif

 // Return the handle of a new paragraph style

 EXPORT_C CParagraphStyle* CParagraphStyle::NewL(const CParaFormatLayer& aGlobalParaFormatLayer,

 												const CCharFormatLayer& aGlobalCharFormatLayer)

 /** Allocates and constructs a CParagraphStyle object whose formatting is based 

 on a global paragraph and character format layer. The type UID is initialised 

 to KUserDefinedParagraphStyleUid. The outline level is not initialised.

 @param aGlobalParaFormatLayer The paragraph format layer on which the style's 

 paragraph formatting is based. 

 @param aGlobalCharFormatLayer The character format layer on which the style's 

 character formatting is based. 

 @return Pointer to the new CParagraphStyle object. */

 	{

 	CParagraphStyle* self=new(ELeave) CParagraphStyle();

 	CleanupStack::PushL(self);

 	self->ConstructL(aGlobalParaFormatLayer,aGlobalCharFormatLayer);

 	CleanupStack::Pop();

 	return self;

 	}

 CParagraphStyle::CParagraphStyle():

 	iType(KUserDefinedParagraphStyleUid)

 	{

 	}

 // Create style and base it on the specified 'Normal' layers

 void CParagraphStyle::ConstructL(const CParaFormatLayer& aGlobalParaFormatLayer,

 										  const CCharFormatLayer& aGlobalCharFormatLayer)

 	{

 	SetBase(&aGlobalParaFormatLayer);

 	//

 	// Force para format layer storage allocation with empty layer

 	TParaFormatMask paraMask;

 	SetL((CParaFormat*)NULL,paraMask);

 	//

 	// Force char format layer storage allocation with empty layer;

 /*	TCharFormat format;

 	TCharFormatMask mask;

 	iCharFormatLayer=CCharFormatLayer::NewL(format,mask);

 */

 	iCharFormatLayer=CCharFormatLayer::NewL();

 	iCharFormatLayer->SetBase(&aGlobalCharFormatLayer);

 	}

 EXPORT_C CParagraphStyle::~CParagraphStyle()

 /** The destructor frees all resources owned by the object, prior to its destruction. */

 	{

 	delete iCharFormatLayer;

 	}

 EXPORT_C CFormatLayer* CParagraphStyle::DoCloneL()const

 	{

 	const CCharFormatLayer* charLayer=STATIC_CAST(const CCharFormatLayer*,iCharFormatLayer->SenseBase());

 	CParagraphStyle* clone=CParagraphStyle::NewL(STATIC_CAST(const CParaFormatLayer&,*SenseBase()),*charLayer);

 	CleanupStack::PushL(clone);

 	CloneLayerL(clone);  // clones the paragraph format layer

 	delete clone->iCharFormatLayer;

 	clone->iCharFormatLayer=NULL;  // necessary precaution if next instruction leaves

 	clone->iCharFormatLayer=iCharFormatLayer->CloneL();  // clones the character format layer

 	clone->iCharFormatLayer->SetBase(charLayer);  // restore the based on link

 	CleanupStack::Pop();  // clone

 	//

 	clone->SetType(Type());

 	clone->SetOutlineLevel(OutlineLevel());

 	clone->iName=iName;

 	//

 	return clone;

 	}

 EXPORT_C TUid CParagraphStyle::Type()const

 /** Gets the style's type UID.

 @return The style's type UID. */

 	{return iType;}

 CParagraphStyle* CParagraphStyle::NewL(RReadStream& aStream,

 										const CParaFormatLayer& aGlobalParaFormatLayer,

 										const CCharFormatLayer& aGlobalCharFormatLayer)

 	{

 	CParagraphStyle* self=new(ELeave) CParagraphStyle();

 	CleanupStack::PushL(self);

 	self->ConstructL(aGlobalParaFormatLayer,aGlobalCharFormatLayer);

 	self->InternalizeL(aStream,&aGlobalParaFormatLayer,&aGlobalCharFormatLayer);

 	CleanupStack::Pop();

 	return self;

 	}

 // Load into this style from the specified readStream.  Base this style on the layer aBase - Default NULL

 void CParagraphStyle::InternalizeL(RReadStream& aStream,const CFormatLayer* aParaLayerBase,const CFormatLayer* aCharLayerBase)

 	{

 	aStream>> iName;

 	aStream>> iType;

 	iOutlineLevel=aStream.ReadInt32L();

 	iCharFormatLayer->InternalizeL(aStream,aCharLayerBase);

 	//

 	CParaFormatLayer::InternalizeL(aStream,aParaLayerBase);

 	}

 // Save the style in the specified WriteStream. The based on link is *NOT* stored.

 void CParagraphStyle::ExternalizeL(RWriteStream& aStream)const

 	{

 	aStream<< iName;

 	aStream<< iType;

 	aStream.WriteInt32L(iOutlineLevel);

 	aStream<< *iCharFormatLayer;

 	//

 	CParaFormatLayer::ExternalizeL(aStream);

 	}

 DLLEXPORT_C void CStyleList::__DbgTestInvariant()const

 // Provides class invariants.  Explanations below:

 //

 	{

 #ifdef _DEBUG

 	TInt styleCount=Count();

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

 		{

 		RParagraphStyleInfo info=iList->At(nn);

 		if (info.iStyleForNextPara)

 			{

 			TInt index=IndexByPtr(info.iStyleForNextPara);

 			// ASSERT: The style-to-follow is present in the list.

 			if (!((info.iStyleForNextPara==NULL) ||

 	                ((info.iStyleForNextPara) && (index!=KErrNotFound && index>=0 && index<styleCount))))

 			    {

 			    OstTrace0( TRACE_DUMP, CSTYLELIST_DBGTESTINVARIANT, "Invariant" );

 			    }

 			__ASSERT_DEBUG(

 				(info.iStyleForNextPara==NULL) ||

 				((info.iStyleForNextPara) && (index!=KErrNotFound && index>=0 && index<styleCount)),User::Invariant());

 			}

 		}

 #endif

 	}

 EXPORT_C CStyleList* CStyleList::NewL(TInt aCapacity /*=KMaxStyleListGranularity*/)

 /** Allocates and constructs an empty CStyleList object with an array granularity.

 @param aCapacity The number of entries by which the array of styles expands 

 when its buffer is reallocated. By default, KMaxStyleListGranularity (= 4). 

 Must be positive or a panic occurs. 

 @return Pointer to the new style list. */

 	{

 	CStyleList* self=new(ELeave) CStyleList();

 	CleanupStack::PushL(self);

 	self->ConstructL(aCapacity);

 	CleanupStack::Pop();

 	return self;

 	}

 EXPORT_C CStyleList* CStyleList::NewL(RReadStream& aStream,

 									  const CParaFormatLayer* aGlobalParaFormatLayer,

 									  const CCharFormatLayer* aGlobalCharFormatLayer)

 /** Allocates and constructs a CStyleList, restoring its contents from the specified 

 stream store. Each style in the list is set to be based on the global format 

 layers specified.

 @param aStream Stream store from which the style list is restored. 

 @param aGlobalParaFormatLayer Pointer to the global paragraph format layer 

 on which all styles in the list are based. 

 @param aGlobalCharFormatLayer Pointer to the global character format layer 

 on which all styles in the list are based. 

 @return Pointer to the new style list. */

 	{

 	CStyleList* self=new(ELeave) CStyleList();

 	CleanupStack::PushL(self);

 	self->InternalizeL(aStream,aGlobalParaFormatLayer,aGlobalCharFormatLayer);

 	CleanupStack::Pop();

 	return self;

 	}

 EXPORT_C CStyleList::CStyleList()

 	{

 	}

 EXPORT_C void CStyleList::ConstructL(TInt aCount)

 // Allocate the style list.

 //

 	{

 	iList=new(ELeave) CArrayFixFlat<RParagraphStyleInfo>(aCount);

 	}

 EXPORT_C CStyleList::~CStyleList()

 /** Deletes all the entries in the list and the list itself. */

 	{

 	KillStyleList();

 	}

 EXPORT_C const RParagraphStyleInfo& CStyleList::At(TInt aIndex)const

 /** Gets a style from the style list, from its index into the array. Two versions 

 are supplied. The compiler chooses the appropriate version based on the use 

 made of the returned reference. If it is used in an expression where that 

 reference can be modified, then the non-const version is chosen.

 @param aIndex The index of the style into the list. The first style is at 

 position zero. Must be within the bounds of the array, or a panic occurs. 

 @return A const reference to the style at position aIndex in the array. 

 @return A non-const reference to the style at position aIndex in the array. */

 	{

 	if (!iList)

 	    {

 	    OstTrace0( TRACE_FATAL, CSTYLELIST_AT, "EStyleIntegrityError" );

 	    }

 	__ASSERT_ALWAYS(iList,Panic(EStyleIntegrityError));

 	if (aIndex<0 || aIndex>=iList->Count())

 	    {

 	    OstTrace0( TRACE_DUMP, DUP3_CSTYLELIST_AT, "EStyleIndexOutOfRange" );

 	    }

 	__ASSERT_DEBUG(aIndex>=0 && aIndex<iList->Count(),Panic(EStyleIndexOutOfRange));

 	return (*iList)[aIndex];

 	}

 EXPORT_C RParagraphStyleInfo& CStyleList::At(TInt aIndex)

 	{

 	if (!iList)

 	    {

 	    OstTrace0( TRACE_FATAL, DUP2_CSTYLELIST_AT, "EStyleIntegrityError" );

 	    }

 	__ASSERT_ALWAYS(iList,Panic(EStyleIntegrityError));

 	if (aIndex<0 || aIndex>=iList->Count())

 	    {

 	    OstTrace0( TRACE_DUMP, DUP1_CSTYLELIST_AT, "EStyleIndexOutOfRange" );

 	    }

 	__ASSERT_DEBUG(aIndex>=0 && aIndex<iList->Count(),Panic(EStyleIndexOutOfRange));

 	return (*iList)[aIndex];

 	}

 EXPORT_C void CStyleList::Reset()

  /** Deletes the contents of the list. */

 	{

 	__TEST_INVARIANT;

 	TInt styleCount=Count();

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

 		delete (iList->At(nn)).iStyle;

 	if (iList)

 		iList->Reset();

 	__TEST_INVARIANT;

 	}

 void CStyleList::KillStyleList()

 	{

 	Reset();

 	delete iList;

 	}

 EXPORT_C TStreamId CStyleList::StoreL(CStreamStore& aStore)const

 /** Stores the style list to a stream store.

 @param aStore Stream store to which the style list is written. 

 @return The ID of the stream store. */

 	{

 	__TEST_INVARIANT;

 	RStoreWriteStream stream;

 	TStreamId id=stream.CreateLC(aStore);

 	//

 	stream<< *this;

 	//

 	stream.CommitL();

 	CleanupStack::PopAndDestroy();

 	return id;

 	}

 EXPORT_C void CStyleList::ExternalizeL(RWriteStream& aStream)const

 /** Externalises the style list to a write stream. The presence of this function 

 means that the standard templated operator<<() (defined in s32strm.h) is available 

 to externalise objects of this class. Does not externalise any styles' based-on 

 links.

 @param aStream Stream to which the object should be externalised. */

 	{

 	__TEST_INVARIANT;

 	TInt count=Count();

 	aStream.WriteUint8L(count);

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

 		{

 		CParagraphStyle* style=(iList->At(mm)).iStyle;

 		style->ExternalizeL(aStream);

 		}

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

 		{

 		RParagraphStyleInfo set=iList->At(nn);

 		CParagraphStyle* style=set.iStyle;

 		TInt offset=(set.iStyleForNextPara!=NULL)

 			? IndexByPtr(style)

 			: -1;

 			if (!(offset==-1 || (offset>=0 && offset<Count())))

 			    {

 			    OstTrace0( TRACE_DUMP, CSTYLELIST_EXTERNALIZEL, "EStyleIntegrityError" );

 			    }

 		__ASSERT_DEBUG(offset==-1 || (offset>=0 && offset<Count()),Panic(EStyleIntegrityError));

 		aStream.WriteInt8L(offset);

 		}

 	}

 EXPORT_C void CStyleList::InternalizeL(RReadStream& aStream,

 									   const CParaFormatLayer* aGlobalParaFormatLayer,

 									   const CCharFormatLayer* aGlobalCharFormatLayer)

 /** Internalises the style list from a read stream. The presence of this function 

 means that the standard templated operator>>() (defined in s32strm.h) is available 

 to internalise objects of this class. Any existing style list contents are 

 replaced.

 @param aStream Stream store from which the style list is internalised. 

 @param aGlobalParaFormatLayer Pointer to the global paragraph format layer 

 on which all styles in the list are based. 

 @param aGlobalCharFormatLayer Pointer to the global character format layer 

 on which all styles in the list are based. */

 	{

 	KillStyleList();

 	TInt styleCount=aStream.ReadUint8L();

 	ConstructL(Max(1,styleCount));  // panics if granularity==0

 	RParagraphStyleInfo holdingSet;

 	iList->AppendL(holdingSet,styleCount);

 	for (TInt mm=0;mm<styleCount;mm++)

 		{// restore the paragraph styles

 		CParagraphStyle* style=CParagraphStyle::NewL(aStream,*aGlobalParaFormatLayer,*aGlobalCharFormatLayer);

 		iList->At(mm).iStyle=style;

 		}

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

 		{// restore the "style for next paragraph" for each paragraph

 		TInt offset=aStream.ReadInt8L();

 		iList->At(nn).iStyleForNextPara=(offset==-1)

 			? NULL

 			: iList->At(offset).iStyle;

 		}

 	__TEST_INVARIANT;

 	}

 EXPORT_C TInt CStyleList::AppendL(RParagraphStyleInfo* aStyleSet)

 /** Appends a style to the style list. The list takes ownership of the style.

 @param aStyleSet The style (and optional style for the following paragraph) 

 to append to the list. 

 @return KErrNone if successful, or KErrAlreadyExists if the style is already 

 present in the list. */

 	{

 	__TEST_INVARIANT;

 	TInt count=Count();

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

 		{

 		if (aStyleSet->iStyle==iList->At(ii).iStyle)

 			return KErrAlreadyExists;  // we already own this style

 		}

 	CleanupStack::PushL(aStyleSet->iStyle);

 	iList->AppendL(*aStyleSet);  // if the append fails, we must take responsibility for the style

 	CleanupStack::Pop();  // aStyleSet.iStyle

 	__TEST_INVARIANT;

 	return KErrNone;

 	}

 EXPORT_C void CStyleList::Remove(CParagraphStyle* aStyle)

 /** Removes a style from the style list. If the style is owned by the list, it 

 is deleted. If the style is not owned by the list, but is referenced by a 

 style owned by the list, (i.e. a style in the list is based on it, or references 

 it as its iStyleForNextPara pointer) then the pointer to aStyle is set to 

 NULL.

 @param aStyle Pointer to the style to remove from the style list, or to set 

 to NULL. */

 	{

 	__TEST_INVARIANT;

 	TInt styles = Count();

 	TInt index = -1;

 	for (TInt i = 0; i < styles; i++)

 		{

 		RParagraphStyleInfo& cur_style = (*iList)[i];

 		if (cur_style.iStyleForNextPara == aStyle)

 			cur_style.iStyleForNextPara = NULL;

 		if (cur_style.iStyle->iBasedOn == aStyle)

 			cur_style.iStyle->iBasedOn = NULL;

 		if (cur_style.iStyle == aStyle)

 			{

 			// Assert that the style must occur only once in the style list.

 			if (index != -1)

 			    {

 			    OstTrace0( TRACE_DUMP, CSTYLELIST_REMOVE, "EStyleIntegrityError" );

 			    }

 			__ASSERT_DEBUG(index == -1,Panic(EStyleIntegrityError));

 			index = i;

 			}

 		}

 	if (index != -1)

 		{

 		delete aStyle;

 		iList->Delete(index);

 		}

 	__TEST_INVARIANT;

 	}

 EXPORT_C TInt CStyleList::SetStyleToFollow(const RParagraphStyleInfo& aStyleSet)

 /** Sets the style to use for the following paragraph for a style in the style 

 list. Both the style (aStyleSet.iStyle) and the style to set for the following 

 paragraph (aStyleSet.iStyleForNextPara) must exist in the style list.

 The function first locates the style (aStyleSet.iStyle) in the list, then 

 sets the style to use for the next paragraph to aStyleSet.iStyleForNextPara.

 If aStyleSet.iStyle does not exist in the style list, the function returns 

 with KErrNotFound. If aStyleSet.iStyleForNextPara does not exist in the style 

 list, a panic occurs.

 @param aStyleSet Identifies a style in the list, and a style to use for its 

 following paragraph. 

 @return KErrNone if successful, or KErrNotFound if the first style contained 

 in the argument (aStyleSet.iStyle) is not in the style list. */

 	{

 	if (IndexByPtr(aStyleSet.iStyleForNextPara) == KErrNotFound)

 	    {

 	    OstTrace0( TRACE_FATAL, CSTYLELIST_SETSTYLETOFOLLOW, "EStyleIntegrityError" );

 	    }

 	__ASSERT_ALWAYS( IndexByPtr(aStyleSet.iStyleForNextPara) != KErrNotFound, Panic(EStyleIntegrityError) );

 	__TEST_INVARIANT;

 	TInt index = IndexByPtr(aStyleSet.iStyle);

 	if (index == KErrNotFound)

 		return index;

 	(*iList)[index].iStyleForNextPara = aStyleSet.iStyleForNextPara;

 	__TEST_INVARIANT;

 	return KErrNone;

 	}

 EXPORT_C RParagraphStyleInfo* CStyleList::PtrByName(const TParagraphStyleName& aName) const

 /** Gets the style with the specified name from the style list.

 @param aName The name of the style to retrieve. 

 @return Pointer to the style with the name specified. NULL if there is no style 

 with this name in the list. */

 	{

 	// Return a pointer to the named style if it's in the list, or null if not.

 	__TEST_INVARIANT;

 	int count = Count();

 	for (int i = 0; i < count; i++)

 		{

 		RParagraphStyleInfo& style_info = (*iList)[i];

 		if (style_info.iStyle != NULL && style_info.iStyle->iName == aName)

 			return &style_info;

 		}

 	return NULL;

 	}

 EXPORT_C RParagraphStyleInfo* CStyleList::PtrByType(const TUid aType) const

 /** Gets the style with the specified type UID from the style list.

 @param aType The UID of the style to retrieve. 

 @return Pointer to the style with the type UID specified. NULL if there is 

 no style with this type in the list. */

 	{

 	// Return a pointer to the first style with the specified type if any; or null if there are none with this type.

 	__TEST_INVARIANT;

 	int count = Count();

 	for (int i = 0; i < count; i++)

 		{

 		RParagraphStyleInfo& style_info = (*iList)[i];

 		if (style_info.iStyle != NULL && style_info.iStyle->Type() == aType)

 			return &style_info;

 		}

 	return NULL;

 	}

 EXPORT_C TInt CStyleList::IndexByPtr(const CParaFormatLayer* aPtr)const

 /** Gets the index into the style list of a specified paragraph style.

 @param aPtr Pointer to the style. 

 @return The style's index into the style list. KErrNotFound if the style is 

 not found in the style list, or if aPtr is a paragraph format layer rather 

 than a style. */

 	{

 	if (aPtr->Type()==KNormalParagraphStyleUid)

 		return KErrNotFound;

 	TInt count=Count();

 	if (count==0)

 		return KErrNotFound;  // ptr cannot be matched cos list is empty.

 	TInt index=0;

 	CParagraphStyle* style=NULL;

 	while (index<count)

 		{

 		style=(*iList)[index].iStyle;

 		if (style==aPtr)

 			break;

 		index++;

 		}

 	return (index<count)

 		? index

 		: KErrNotFound;

 	}

 EXPORT_C TInt CStyleList::IndexByName(const TDesC& aName)const

 /** Gets the index into the style list of a specified paragraph style, identified 

 by its name.

 @param aName The name of the style. 

 @return The style's index into the style list. KErrNotFound if the style name 

 is not found in the style list. */

 	{

 	TInt count=Count();

 	if (count==0)

 		return KErrNotFound;  // name cannot be in list cos its empty.

 	TInt index=0;

 	CParagraphStyle* style=NULL;

 	while (index<count)

 		{

 		style=(*iList)[index].iStyle;

 		if (style != NULL && style->iName == aName)

 			break;

 		index++;

 		}

 	return (index<count)

 		? index

 		: KErrNotFound;

 	}

 EXPORT_C CStyleList* CStyleList::DeepCloneL() const

 /** Creates and returns a style list which is a clone of the current style list.

 @return Pointer to a clone of the current style list. */

 	{

 	__TEST_INVARIANT;

 	CStyleList* newList = CStyleList::NewL();

 	CleanupStack::PushL(newList);

 	TInt styleCount=Count();

 	for (TInt styleItem=0;styleItem<styleCount;styleItem++)

 		{

 		const RParagraphStyleInfo& source=iList->At(styleItem);

 		CParagraphStyle* style=source.iStyle->CloneL();

 		RParagraphStyleInfo info(style,source.iStyleForNextPara);

 		newList->AppendL(&info);

 		}

 	CleanupStack::Pop();

 	return newList;

 	}