/*

 * Copyright (c) 2003-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 "TXTFRMAT.H"

 #include "TXTFMLYR.H"

 #include <txtfmstm.h>

 #include "TXTSTD.H"

 #include "OstTraceDefinitions.h"

 #ifdef OST_TRACE_COMPILER_IN_USE

 #include "TXTFMLYRTraces.h"

 #endif

 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

 #include "TXTFMLYR_INTERNAL.H"

 #endif

 CFormatLayer::CFormatLayer()

 	{

 	}

 CFormatLayer::~CFormatLayer()

 	{

 	iStore.Reset();

 	}

 DLLEXPORT_C void CFormatLayer::__DbgTestInvariant() const

 	{

 	}

 EXPORT_C void CFormatLayer::SetBase(const CFormatLayer* aBaseFormatLayer)

 /** Sets the format layer which this layer's based-on link points to.

 @param aBaseFormatLayer The format layer which this layer's based-on link 

 points to. Specify NULL if this is the final layer in the chain (the layer 

 on which all other layers are based). */

 	{

 	iBasedOn = aBaseFormatLayer;

 	}

 EXPORT_C const CFormatLayer* CFormatLayer::SenseBase() const

 /** Gets the format layer which this layer's based-on link points to. If NULL, 

 this layer is the final layer in the chain.

 @return The format layer on which this layer is based. */

 	{

 	return iBasedOn;

 	}

 EXPORT_C TInt CFormatLayer::ChainCount() const

 /** Gets the number of format layers in the chain, inclusive of itself. Assumes 

 that the format layer chain has been correctly set up to terminate with a 

 NULL based-on link.

 @return The number of format layers in the chain, counting from the current 

 layer. */

 	{

 	TInt chainCount=1;

 	const CFormatLayer* next=iBasedOn;

 	while (next)

 		{

 		++chainCount;

 		next=next->iBasedOn;

 		}

 	return chainCount;

 	}

 const TUint8* CFormatLayer::Ptr(TInt& aSize)const

 /** Return a pointer to the stored bytecode.*/	

     {

 	return iStore.Ptr(aSize);

 	}

 EXPORT_C void CFormatLayer::Reset()

 /** Deletes the contents of the format layer. The based-on link is not affected. */

 	{

 	iStore.Reset();

 	}

 EXPORT_C void CFormatLayer::InternalizeChainL(RReadStream& aStream,const CFormatLayer* aBase)

 /** Restores a chain of format layers from a read stream. The layer at the end 

 of the chain (the one furthest from this layer) is set to be based on the 

 specified layer aBase, which may be NULL. This layer is set to be at the head 

 of the restored chain (i.e. no other layers are based on it).

 @param aStream Stream from which the format layer chain should be internalised. 

 @param aBase The format layer at the end of the chain (furthest from this layer). 

 May be NULL. */

 	{

 	TInt chainLength=aStream.ReadInt8L();

 	if (chainLength<1)

 		User::Leave(KErrCorrupt);  // Must restore at least one layer (this), else corrupt stream.

 	TInt descendentCount=chainLength-1;

 	for (TInt loop=0;loop<descendentCount;loop++)

 		{// Restore each descendent of [this] layer.

 		CFormatLayer* layer=RestoreNewL(aStream);

 		layer->SetBase(aBase);

 		CleanupStack::PushL(layer);

 		aBase=layer;

 		}

 	aStream>> *this;

 	SetBase(aBase);

 	CleanupStack::Pop(descendentCount);

 	}

 EXPORT_C void CFormatLayer::ExternalizeChainL(RWriteStream& aStream,TInt aExcludeCount)const

 /** Stores a chain of format layers. By default an entire chain is stored unless 

 an exclude count is provided. In this case, the length of the chain stored 

 is the ChainCount() minus the exclude count. The excluded layers are the ones 

 starting with the layer with the NULL based-on link.

 Note

 The exclude count must be zero or greater but must be less than the total 

 number of layers in the chain, otherwise a panic occurs.

 @param aStream Stream to which the format layer chain should be externalised. 

 @param aExcludeCount The number of layers to be excluded. By default, zero. */

 	{

 // ASSERT: aExcludeCount is positive.

 	if (aExcludeCount<0)

 	    {

 	    OstTrace0( TRACE_FATAL, CFORMATLAYER_EXTERNALIZECHAINL, "ECannotStoreFormatLayerChain" );

 	    }

 	__ASSERT_ALWAYS(aExcludeCount>=0,Panic(ECannotStoreFormatLayerChain));

 // ASSERT: The number of layers to be excluded is less than the total no. of layers.

 	if (aExcludeCount>=ChainCount())

 	    {

 	    OstTrace0( TRACE_FATAL, DUP1_CFORMATLAYER_EXTERNALIZECHAINL, "ECannotStoreFormatLayerChain" );

 	    }

 	__ASSERT_ALWAYS(aExcludeCount<ChainCount(),Panic(ECannotStoreFormatLayerChain));

 	TInt aCount=ChainCount()-aExcludeCount;

 	aStream.WriteInt8L(aCount);  // Store the chain length.

 	ExternalizeLayersRecurseL(aStream,--aCount);

 	}	

 void CFormatLayer::ExternalizeLayersRecurseL(RWriteStream& aStream,TInt aDescendantCount)const

 /** Stores a format layer chain with *aLength* number of layers in a stack-like 

 fashion. This necessitates navigating to the end of the chain and storing the 

 layers as we unwind back to the top of the chain.*/

 //

 	{

 	if (aDescendantCount)

 		{

 // ASSERT: The format layer chain is consistent.

 		if (iBasedOn==NULL)

 		    {

 		    OstTrace0( TRACE_DUMP, CFORMATLAYER_EXTERNALIZELAYERSRECURSEL, "ECorruptFormatLayerChain" );

 		    }

 		__ASSERT_ALWAYS(iBasedOn!=NULL,Panic(ECorruptFormatLayerChain));

 		iBasedOn->ExternalizeLayersRecurseL(aStream,--aDescendantCount);

 		}

 	aStream<< *this;

 	}

 /** Implementations of this function compare another format layer with the

 current object. For the two layers to be equal, they must have the same 

 contents and (if the second parameter is ETrue),their based-on links must 

 point to the same format layer.

 @param aLayer The layer to compare to this format layer.

 @param aCheckBasedOnLink If ETrue, both layers' based-on links must point to 

 the same format layer. If EFalse, the based-on links are not used in the 

 comparison. By default, ETrue.

 @return  ETrue if the two layers are identical, otherwise EFalse. */

 TBool CFormatLayer::IsIdentical(const TUint8* aPtr,TInt aSize) const

 	{

 	TInt size=0;

 	const TUint8* ptr=iStore.Ptr(size);

 	if ((ptr==NULL && aPtr!=NULL) || (ptr!=NULL && aPtr==NULL))

 		return EFalse;

 	if (ptr==NULL && aPtr==NULL)

 		return ETrue;

 	return (!(TBool)(Mem::Compare(ptr,size,aPtr,aSize)));

 	}

 /** Tests whether any formatting is stored in the format layer.

 @return ETrue if no formatting is stored in the format layer, otherwise returns 

 EFalse. */

 EXPORT_C TBool CFormatLayer::IsEmpty() const

 	{

 	TInt size=0;

 	return iStore.Ptr(size)==NULL;

 	}

 /** Swaps the contents of this with aLayer.

 @param aLayer The layer to swap contents with.

 @internalComponent */

 void CFormatLayer::Swap(CFormatLayer& aLayer)

 	{

 	iStore.Swap(aLayer.iStore);

 	const CFormatLayer* t = iBasedOn;

 	iBasedOn = aLayer.iBasedOn;

 	aLayer.iBasedOn = t;

 	}

 /** Allocates and constructs an empty CParaFormatLayer. Its based-on link is 

 NULL.

 Note: Use SetL() to set format attributes in the layer. Use SetBase(), defined 

 in the base class CFormatLayer, to set the layer's based on link.

 @return Pointer to the new paragraph format layer. */

 EXPORT_C CParaFormatLayer* CParaFormatLayer::NewL()

 	{

 	return new(ELeave) CParaFormatLayer;

 	}

 EXPORT_C CParaFormatLayer* CParaFormatLayer::NewL(RReadStream& aStream)

 /** Allocates and constructs a CParaFormatLayer, restoring its format attributes 

 from a stream. The layer's based-on link is set to NULL.

 @param aStream Stream from which the layer is restored. 

 @return Pointer to the new paragraph format layer. */

 	{

 	CParaFormatLayer* self=NewL();

 	CleanupStack::PushL(self);

 	self->InternalizeL(aStream);

 	CleanupStack::Pop();

 	return self;

 	}

 EXPORT_C CParaFormatLayer* CParaFormatLayer::NewL(const CParaFormat* aFormat,const TParaFormatMask& aMask)

 /** Allocates and constructs a CParaFormatLayer. The attributes which are set 

 in the mask are initialised to the values specified in the format container 

 aParaFormat. The attributes which are not set in the mask are initialised to 

 the default values for class CParaFormat. The new layer's based-on link is set 

 to NULL.

 @param aParaFormat Contains the attribute values to assign to the format layer. 

 @param aMask Mask specifying which attributes should be initialized from 

 aParaFormat. 

 @return Pointer to ParaFormatLayer the new paragraph format layer. */

 	{

 	CParaFormatLayer* self=NewL();

 	CleanupStack::PushL(self);

 	self->SetL(aFormat,aMask);

 	CleanupStack::Pop();

 	return self;

 	}

 CParaFormatLayer* CParaFormatLayer::NewL(const CParaFormatLayer* aLayer)

 /** Copying construction

  does not copy the based on link*/

 	{

 	CParaFormatLayer* self=NewL();  // based-on is NULL

 	CleanupStack::PushL(self);

 	aLayer->CloneLayerL(self);

 	CleanupStack::Pop();			// self

 	return self;

 	}

 CParaFormatLayer* CParaFormatLayer::NewCopyBaseL(const CParaFormatLayer* aLayer)

 /** Copying construction

  copies based-on link*/

 	{

 	CParaFormatLayer* self=NewL(aLayer);  // based-on is NULL

 	self->iBasedOn=aLayer->iBasedOn;

 	return self;

 	}

 CParaFormatLayer::CParaFormatLayer()

 /** Constructor.*/

 // No ConstructL method since allocation is postponed until first Set.

 //

 	{

 	}

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

 /** Externalises the paragraph format layer but not its based-on link 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.

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

 	{aStream<< iStore;}

 EXPORT_C void CParaFormatLayer::InternalizeL(RReadStream& aStream,const CFormatLayer* aBase)

 /** Internalises the paragraph format layer but not its based-on link 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. The internalised layer is set to be based on the layer specified.

 @param aStream Stream from which the format layer should be internalised. 

 @param aBase The based-on link to assign to the layer. By default NULL. */

 	{

 	aStream>> iStore;

 	SetBase(aBase);

 	}

 EXPORT_C void CParaFormatLayer::SetL(const CParaFormat* aDesiredEffectiveFormat,const TParaFormatMask& aMask)

 /** Sets the layer's format attributes. The attributes which are set in the 

 mask are set in the layer to the values specified in the format container 

 aDesiredEffectiveFormat. The attributes which are not set in the mask are not 

 changed.

 Note: Any tab stops in aDesiredEffectiveFormat are merged with the tab stops in 

 the current layer.

 @param aDesiredEffectiveFormat Contains the attribute values to assign to 

 the format layer. 

 @param aMask Mask specifying which attributes should be set from 

 aDesiredEffectiveFormat. */

 	{

 	if ( !aDesiredEffectiveFormat )

 		{

 		return;

 		}

 	const CParaFormat& desiredFormat = *aDesiredEffectiveFormat;

 	CParaFormat currentEffectiveFormat;

 	ResetOnCleanupL( &currentEffectiveFormat);

 	if (iBasedOn)

 		((CParaFormatLayer*)iBasedOn)->SenseEffectiveL(&currentEffectiveFormat);

 	iStore.SetParaFormatL(desiredFormat,aMask,currentEffectiveFormat);

 	CleanupStack::Pop();

 	}

 EXPORT_C void CParaFormatLayer::SenseEffectiveL(CParaFormat* aParaFormat,CParaFormat::TParaFormatGetMode aMode)const

 /** Senses the layer's effective format, searching all based-on links. The 

 resulting aParaFormat is fully populated, except that if aMode is 

 EFixedAttributes, then only the fixed attributes (not tabs, paragraph borders 

 or bullets) are written to it.

 Notes:

 The function also "tidies up" the layer's effective paragraph formatting, 

 so that any zero height bullets, paragraph borders with a NULL line style 

 or NULL tab stops are removed. 

 The function can only leave if aMode has a value of EAllAttributes.

 @param aParaFormat On return, contains the layer's effective formatting. 

 Depending on the value of aMode, tabs, borders and bullets may be excluded. 

 Must not be NULL or a panic occurs. 

 @param aMode Controls which attributes are written to aParaFormat. If 

 EAllAttributes, all attributes are written; if EFixedAttributes, tabs, 

 bullets and borders are not written. */

 	{

 	if (aParaFormat==NULL)

 	    {

 	    OstTrace0( TRACE_FATAL, CPARAFORMATLAYER_SENSEEFFECTIVEL, "ENullFormatPointer" );

 	    }

 	__ASSERT_ALWAYS(aParaFormat!=NULL,Panic(ENullFormatPointer));

 	aParaFormat->Reset();

 	TParaFormatMask mask;

 	FillParaFormatL(aParaFormat,mask,aMode);

 	CleanupEffectiveFormat(aParaFormat,mask);

 	}

 EXPORT_C void CParaFormatLayer::SenseL(CParaFormat* aParaFormat,TParaFormatMask& aMask,CParaFormat::TParaFormatGetMode aMode)const

 /** Senses the formatting which has been applied to the current layer only. No 

 based-on links are searched. This function does not get the effective formatting, 

 but the resulting aParaFormat is useable even if not all attributes are flagged 

 for sensing in aMask because any attribute values not sensed from the current 

 layer, are set to default values.

 The function can only leave if aMode has a value of EAllAttributes.

 @param aParaFormat On return, contains the formatting which has been applied 

 to the current layer only. Any attributes not explicitly set in the current 

 layer are initialised to the default values for a CParaFormat. Attributes 

 specified in aMask are not sensed from this layer. The values for these 

 attributes are also initialised to the default settings. Must not be NULL or 

 a panic occurs. 

 @param aMask A bitmask. Any attributes which are set in the mask as passed 

 into the function are not sensed from the current layer. On return, indicates 

 the attributes which were sensed from this layer. So, normally, when passed 

 to the function, all attributes in the mask should be unset. 

 @param aMode Controls which attributes are written to aParaFormat. If 

 EAllAttributes, all attributes are written; if EFixedAttributes, tabs, bullets 

 and borders are not written. */

 	{

 	if (aParaFormat==NULL)

 	    {

 	    OstTrace0( TRACE_FATAL, CPARAFORMATLAYER_SENSEL, "ENullFormatPointer" );

 	    }

 	__ASSERT_ALWAYS(aParaFormat!=NULL,Panic(ENullFormatPointer));

 	iStore.SenseParaFormatL(*aParaFormat,aMask,aMode);

 	}

 void CFormatLayer::CloneLayerL(CFormatLayer* aClone)const

 	{

 	aClone->iStore.CopyL(iStore);

 	}

 EXPORT_C CFormatLayer* CParaFormatLayer::DoCloneL()const

 //

 //

 	{

 	return NewL(this);  // use copy construction

 	}

 EXPORT_C TBool CParaFormatLayer::IsIdenticalL(const CParaFormat* aParaFormat,const TParaFormatMask& aMask)const

 /** Compares a format attribute container with the current layer. For the two 

 objects to be identical, the current layer must contain only the attributes 

 specified in the argument aMask, and these attributes must have the same values 

 as those in aParaFormat. None of the current layer's based-on links are searched.

 @param aParaFormat Contains the attribute values used in the comparison. 

 @param aMask A bitmask specifying which attributes are relevant to the function. 

 @return ETrue if the formatting of the current layer exactly matches that 

 contained in aParaFormat. Otherwise EFalse. */

 	{

 	CParaFormat* thisParaFormat=CParaFormat::NewLC();

 	TParaFormatMask thisParaFormatMask;

 	SenseL(thisParaFormat,thisParaFormatMask);

 	TBool result=EFalse;

 	if (thisParaFormatMask!=aMask)

 		result=EFalse;

 	else if (thisParaFormat->IsEqual(*aParaFormat,aMask))

 		result=ETrue;

 	CleanupStack::PopAndDestroy();

 	return result;

 	}

 EXPORT_C TBool CParaFormatLayer::IsIdentical(CFormatLayer* aLayer,TBool aCheckBasedOnLink)const

 /** Compares another paragraph format layer with the current layer. For the two 

 layers to be equal, they must have the same contents and (if the second 

 parameter is ETrue), their based-on links must point to the same format layer.

 @param aLayer The paragraph format layer to compare to this format layer. 

 @param aCheckBasedOnLink If ETrue, both layers' based-on links must point to 

 the same format layer. If EFalse, the based-on links are not used in the 

 comparison. By default, ETrue. 

 @return ETrue if the two layers are identical, otherwise EFalse. */

 	{

 	if (aCheckBasedOnLink)

 		{

 		if (iBasedOn!=aLayer->SenseBase())

 			return EFalse;

 		}

 	TInt size;

 	const TUint8* ptr=((CParaFormatLayer*)aLayer)->Ptr(size);		// some design went wrong here!

 	return CFormatLayer::IsIdentical(ptr,size);

 	}

 EXPORT_C const TUint8* CParaFormatLayer::Ptr(TInt& aSize)const

 /** Gets a pointer to the start of the buffer containing the layer's format 

 attribute values.

 @param aSize On return, set to the size of the buffer. 

 @return Pointer to the buffer which contains the layer's format attribute 

 values. */

 	{return CFormatLayer::Ptr(aSize);}

 EXPORT_C TUid CParaFormatLayer::Type()const

 /** Returns the paragraph format layer UID. This can be used to distinguish 

 between an ordinary paragraph format layer and paragraph styles, which have a 

 different UID.

 @return The UID of a paragraph format layer (KNormalParagraphStyleUid). */

 	{return KNormalParagraphStyleUid;}

 CFormatLayer* CParaFormatLayer::RestoreNewL(RReadStream& aStream)

 /** Return a new CParaFormatLayer, having restored it from aStream.

  Overrides the base class method, to provide a new format layer of the correct 

  type.*/

 	{return NewL(aStream);}

 void CParaFormatLayer::FillParaFormatL(CParaFormat* aParaFormat,TParaFormatMask& aMask,CParaFormat::TParaFormatGetMode aMode)const

 /** Fills aParaFormat by dumping the current format layer into it.  

 Next traverse the 'basedOn' link if it is not NULL, and repeat.*/

 	{

 	if ( !aParaFormat )

 		{

 		return;

 		}

 	CParaFormat& senseFormat = *aParaFormat;

 	iStore.SenseParaFormatL(senseFormat,aMask,aMode);

 	if (iBasedOn)

 		((CParaFormatLayer*)iBasedOn)->FillParaFormatL(aParaFormat,aMask,aMode);

 	}

 void CParaFormatLayer::CleanupEffectiveFormat(CParaFormat* aParaFormat,TParaFormatMask aMask)const

 /** Removes anti-tabs, zero height and null bullets, and paragraph borders with

  null linestyles, from aParaFormat.  An effective format does not support the

  notion of anti-tabs etc.*/

 	{

 	if (aMask.AttribIsSet(EAttBullet))

 		{

 		if (aParaFormat->iBullet->iStyle == TBullet::ENullStyle || aParaFormat->iBullet->iHeightInTwips <= 0)

 			{

 			delete aParaFormat->iBullet;

 			aParaFormat->iBullet = NULL;

 			}

 		}

 	if (aMask.AttribIsSet(EAttTopBorder) ||

 		aMask.AttribIsSet(EAttBottomBorder) ||

 		aMask.AttribIsSet(EAttLeftBorder) ||

 		aMask.AttribIsSet(EAttRightBorder))

 		CleanupBorders(aParaFormat);

 	if (aMask.AttribIsSet(EAttTabStop))

 		{

 		int index = 0;

 		while (index < aParaFormat->TabCount())

 			{

 			TTabStop tab = aParaFormat->TabStop(index);

 			if (tab.iType == TTabStop::ENullTab)

 				aParaFormat->RemoveTab(tab.iTwipsPosition);

 			else

 				index++;

 			}

 		}

 	}

 void CParaFormatLayer::CleanupBorders(CParaFormat* aParaFormat)const

 /** Destroys the paragraph border if it is of NULL linestyle,

  and nulls the pointer to it (aBorder).*/

 	{

 	if (aParaFormat->ParaBorder(CParaFormat::EParaBorderTop).iLineStyle==TParaBorder::ENullLineStyle &&

 		aParaFormat->ParaBorder(CParaFormat::EParaBorderBottom).iLineStyle==TParaBorder::ENullLineStyle &&

 		aParaFormat->ParaBorder(CParaFormat::EParaBorderLeft).iLineStyle==TParaBorder::ENullLineStyle &&

 		aParaFormat->ParaBorder(CParaFormat::EParaBorderRight).iLineStyle==TParaBorder::ENullLineStyle)

 		{

 		aParaFormat->RemoveAllBorders();

 		}

 	}

 EXPORT_C CCharFormatLayer* CCharFormatLayer::NewL()

 /** Allocates and constructs an empty CCharFormatLayer. Its based-on link is 

 NULL.

 Note: Use SetL() to set format attributes in the layer. Use SetBase(), defined 

 in the base class CFormatLayer, to set the layers based on link.

 @return Pointer to the new character format layer. */

 	{return new(ELeave)CCharFormatLayer;}

 EXPORT_C CCharFormatLayer* CCharFormatLayer::NewL(RReadStream& aStream)

 /** Allocates and constructs a CCharFormatLayer, restoring its format attributes 

 from a stream. The layer's based-on link is set to NULL.

 @param aStream Stream from which the layer is restored. 

 @return Pointer to the new character format layer. */

 	{

 	CCharFormatLayer* self=NewL();

 	CleanupStack::PushL(self);

 	self->InternalizeL(aStream);

 	CleanupStack::Pop();

 	return self;

 	}

 EXPORT_C CCharFormatLayer* CCharFormatLayer::NewL(const TCharFormat& aFormat,const TCharFormatMask& aMask)

 /** Returns a handle to a new charFormatLayer, after constructing

  it and setting it with the specified format and format mask.*/

 	{

 	CCharFormatLayer* self=NewL();

 	CleanupStack::PushL(self);

 	self->SetL(aFormat,aMask);

 	CleanupStack::Pop();

 	return self;

 	}

 CCharFormatLayer* CCharFormatLayer::NewL(const TCharFormatX& aFormat,const TCharFormatXMask& aMask)

 	{

 	CCharFormatLayer* self = NewL();

 	CleanupStack::PushL(self);

 	self->SetL(aFormat,aMask);

 	CleanupStack::Pop();

 	return self;

 	}

 CCharFormatLayer* CCharFormatLayer::NewL(const CCharFormatLayer* aLayer)

 /** Copying construction

  does not copy based-on link.*/

 	{

 	CCharFormatLayer* self=NewL();  // based-on is NULL

 	CleanupStack::PushL(self);

 	aLayer->CloneLayerL(self);

 	CleanupStack::Pop();			// self

 	return self;

 	}

 CCharFormatLayer* CCharFormatLayer::NewCopyBaseL(const CCharFormatLayer* aLayer)

 /** Copying construction

  copies based-on link*/

 	{

 	CCharFormatLayer* self=NewL(aLayer);  // based-on is NULL

 	self->iBasedOn=aLayer->iBasedOn;

 	return self;

 	}

 CCharFormatLayer::CCharFormatLayer()

 	{

 	}

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

 /** Externalises the character format layer but not its based-on link 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.

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

 	{

 	aStream << iStore;

 	}

 EXPORT_C void CCharFormatLayer::InternalizeL(RReadStream& aStream,const CFormatLayer* aBase)

 /** Internalises the character format layer but not its based-on link 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. The internalised layer is set to be based on the layer specified.

 @param aStream Stream from which the format layer should be internalised. 

 @param aBase The based-on link to assign to the layer. By default NULL. */

 	{

 	aStream >> iStore;

 	SetBase(aBase);

 	}

 EXPORT_C const TUint8* CCharFormatLayer::Ptr(TInt& aSize)const

 /** Gets a pointer to the start of the buffer containing the layer's format 

 attribute values.

 @param aSize On return, set to the size of the buffer. 

 @return Pointer to the buffer which contains the layer's format attribute 

 values. */

 	{

 	return CFormatLayer::Ptr(aSize);

 	}

 EXPORT_C void CCharFormatLayer::SetL(const TCharFormat& aCharFormat,const TCharFormatMask& aMask)

 /** Sets the layer's format attributes. The attributes which are set in the 

 mask are set in the layer to the values specified in the format container 

 aCharFormat. The attributes which are not set in the mask are not changed.

 @param aCharFormat Contains the attribute values to assign to the format layer. 

 @param aMask Mask specifying which attributes should be set from aCharFormat. */

 	{

 	TCharFormatX format(aCharFormat);

 	iStore.SetCharFormatL(format,aMask);

 	}

 void CCharFormatLayer::SetL(const TCharFormatX& aCharFormat,const TCharFormatXMask& aMask)

 /** Sets the layer's format attributes. The attributes which are set in the 

 mask are set in the layer to the values specified in the format container 

 aCharFormat. The attributes which are not set in the mask are not changed.

 @param aCharFormat Contains the attribute values to assign to the format layer. 

 @param aMask Mask specifying which attributes should be set from aCharFormat. */

 	{

 	iStore.SetCharFormatL(aCharFormat,aMask);

 	}

 EXPORT_C void CCharFormatLayer::SenseEffective(TCharFormat& aCharFormat)const

 /** Senses the layer's effective format, searching all based-on links. The 

 resulting aCharFormat is fully populated.

 @param aCharFormat On return, contains the layer's effective formatting. */

 	{

 	TCharFormatX format;

 	TCharFormatXMask mask;

 	FillCharFormat(format,mask);

 	aCharFormat = format.iCharFormat;

 	}

 void CCharFormatLayer::SenseEffective(TCharFormatX& aCharFormat) const

 /** Senses the layer's effective format, searching all based-on links. The 

 resulting aCharFormat is fully populated.

 @param aCharFormat On return, contains the layer's effective formatting. */

 	{

 	TCharFormatXMask mask;

 	aCharFormat = TCharFormatX(); // initialise character format; FillCharFormat doesn't do this

 	FillCharFormat(aCharFormat,mask);

 	}

 EXPORT_C void CCharFormatLayer::Sense(TCharFormat& aCharFormat,TCharFormatMask& aMask)const

 /** Senses the formatting which has been applied to the current layer only. No 

 based-on links are searched. This function does not get the layer's effective 

 formatting, but the resulting aCharFormat is fully populated, even if not 

 all attributes are flagged for sensing in aMask because any attribute values 

 not sensed from the current layer are set to default values.

 @param aCharFormat On return, contains the formatting which has been applied 

 to the current layer only. Any attributes not explicitly set in the current 

 layer are set to the default values for a TCharFormat. Any attributes specified 

 in aMask are not sensed from this layer. The values for these attributes are 

 also initialised to the default settings. 

 @param aMask A bitmask. Any attributes which are set in the mask as passed 

 into the function are not sensed from the current layer. On return, indicates 

 the attributes which were sensed from this layer. So, normally, when passed 

 to the function, all attributes in the mask should be unset. */

 	{

 	TCharFormatX format(aCharFormat);

 	TCharFormatXMask mask = aMask;

 	iStore.SenseCharFormat(format,mask);

 	aCharFormat = format.iCharFormat;

 	mask.ClearExtendedAttribs();

 	aMask = mask;

 	}

 void CCharFormatLayer::Sense(TCharFormatX& aCharFormat,TCharFormatXMask& aMask) const

 /** Senses the formatting which has been applied to the current layer only. No 

 based-on links are searched. This function does not get the layer's effective 

 formatting, but the resulting aCharFormat is fully populated, even if not 

 all attributes are flagged for sensing in aMask because any attribute values 

 not sensed from the current layer are set to default values.

 @param aCharFormat On return, contains the formatting which has been applied 

 to the current layer only. Any attributes not explicitly set in the current 

 layer are set to the default values for a TCharFormat. Any attributes specified 

 in aMask are not sensed from this layer. The values for these attributes are 

 also initialised to the default settings. 

 @param aMask A bitmask. Any attributes which are set in the mask as passed 

 into the function are not sensed from the current layer. On return, indicates 

 the attributes which were sensed from this layer. So, normally, when passed 

 to the function, all attributes in the mask should be unset. */

 	{

 	iStore.SenseCharFormat(aCharFormat,aMask);

 	}

 EXPORT_C CFormatLayer* CCharFormatLayer::DoCloneL()const

 	{

 	return NewL(this);  // use copy construction

 	}

 EXPORT_C TBool CCharFormatLayer::IsIdentical(CFormatLayer* aLayer,TBool aCheckBasedOnLink)const

 /** Compares another character format layer with the current layer. For the two 

 layers to be equal, they must have the same contents and (if the second 

 parameter is ETrue), their based-on links must point to the same format layer.

 @param aLayer The character format layer to compare to this format layer. 

 @param aCheckBasedOnLink If ETrue, both layers' based-on links must point to 

 the same format layer. If EFalse, the based-on links are not used in the 

 comparison. By default, ETrue. 

 @return ETrue if the two layers are identical, otherwise EFalse. */

 	{

 	if (aCheckBasedOnLink)

 		{

 		if (iBasedOn!=aLayer->SenseBase())

 			return EFalse;

 		}

 	TInt size;

 	const TUint8* ptr=((CCharFormatLayer*)aLayer)->Ptr(size);		// some naff design at work here!

 	return CFormatLayer::IsIdentical(ptr,size);

 	}

 EXPORT_C TBool CCharFormatLayer::IsIdentical(const TCharFormat& aCharFormat,const TCharFormatMask& aMask)const

 /** Compares a format attribute container with the current layer. For the two 

 objects to be identical, the current layer must contain only the attributes 

 specified in the argument aMask, and these attributes must have the same 

 values as those in aCharFormat. None of the current layer's based-on links are 

 searched.

 @param aCharFormat Contains the attribute values used in the comparison. 

 @param aMask A bitmask specifying which attributes are relevant to the function. 

 @return ETrue if the formatting of the current layer exactly matches that 

 contained in aCharFormat, otherwise EFalse. */

 	{

 	TCharFormat thisCharFormat;

 	TCharFormatMask thisCharFormatMask;

 	Sense(thisCharFormat,thisCharFormatMask);

 	if (thisCharFormatMask!=aMask)

 		return EFalse;

 	return thisCharFormat.IsEqual(aCharFormat,aMask);

 	}

 CFormatLayer* CCharFormatLayer::RestoreNewL(RReadStream& aStream)

 /** Return a new CCharFormatLayer, having restored it from aStream.

 Overrides the base class method, to provide a new format layer of 

 the correct type.*/

 	{return CCharFormatLayer::NewL(aStream);}

 void CCharFormatLayer::FillCharFormat(TCharFormatX& aCharFormat,TCharFormatXMask& aMask)const

 /** Fills aCharFormat by dumping the current format layer into it, then follows 

 each 'BasedOn' link in turn if it is not null.  It is assumed that all based on 

 links eventually terminate with nulls.*/

 	{

 	iStore.SenseCharFormat(aCharFormat,aMask);

 	if (iBasedOn)

 		((CCharFormatLayer*)iBasedOn)->FillCharFormat(aCharFormat,aMask);

 	}