/*

* 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. */

	{