diff -r 000000000000 -r 1fb32624e06b textrendering/texthandling/stext/TXTFMLYR.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/textrendering/texthandling/stext/TXTFMLYR.CPP Tue Feb 02 02:02:46 2010 +0200 @@ -0,0 +1,813 @@ +/* +* 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 +#include +#include "TXTFRMAT.H" +#include "TXTFMLYR.H" +#include +#include "TXTSTD.H" + +#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;loopSetBase(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. + __ASSERT_ALWAYS(aExcludeCount>=0,Panic(ECannotStoreFormatLayerChain)); +// ASSERT: The number of layers to be excluded is less than the total no. of layers. + __ASSERT_ALWAYS(aExcludeCountExternalizeLayersRecurseL(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( ¤tEffectiveFormat); + if (iBasedOn) + ((CParaFormatLayer*)iBasedOn)->SenseEffectiveL(¤tEffectiveFormat); + 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. */ + { + __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. */ + { + __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); + }