1 /*

     2 * Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 #include <e32std.h>

    20 

    21 #include <s32strm.h>

    22 #include <s32mem.h>

    23 #include "TXTFRMAT.H"

    24 #include <txtfmstm.h>

    25 

    26 #include "TXTSTD.H"

    27 

    28 const TInt KMaxFormatStreamLength=0x400;  // 1024 bytes

    29 

    30 // Standard attributes

    31 const TUint KFontProportional=0x01;

    32 const TUint KFontSerif=0x02;

    33 const TUint KFontSymbol=0x04;

    34 

    35 const TUint KTypefaceFlags=sizeof(TUint8);

    36 const TInt KTypeSize=sizeof(TUint8);

    37 const TInt KColor=sizeof(TUint8)+sizeof(TUint8)+sizeof(TUint8);

    38 const TInt KFontHeight=sizeof(TInt32);

    39 const TInt KParaBorderThickness=sizeof(TInt32);

    40 const TInt KTabPosition=sizeof(TUint32);

    41 const TInt KTabType=sizeof(TUint8);

    42 

    43 // Paragraph format attributes

    44 const TInt KVariableLengthAttribute=0;

    45 const TInt KParaLanguage=sizeof(TUint8);

    46 const TInt KParaFillColor=KColor;

    47 const TInt KParaLeftMargin=sizeof(TInt32);

    48 const TInt KParaRightMargin=sizeof(TInt32);

    49 const TInt KParaIndent=sizeof(TInt32);

    50 const TInt KParaAlignment=sizeof(TUint8);

    51 const TInt KParaVerticalAlignment=sizeof(TUint8);

    52 const TInt KParaLineSpacing=sizeof(TInt32);

    53 const TInt KParaLineSpacingControl=sizeof(TUint8);

    54 const TInt KParaSpaceBefore=sizeof(TInt32);

    55 const TInt KParaSpaceAfter=sizeof(TInt32);

    56 const TInt KParaKeepTogether=sizeof(TUint8);

    57 const TInt KParaKeepWithNext=sizeof(TUint8);

    58 const TInt KParaStartNewPage=sizeof(TUint8);

    59 const TInt KParaWidowOrphan=sizeof(TUint8);

    60 const TInt KParaWrap=sizeof(TUint8);

    61 const TInt KParaBorderMargin=sizeof(TInt32);

    62 const TInt KParaTopBorder=sizeof(TUint8)+KParaBorderThickness+KColor+sizeof(TUint8);//linestyle/thickness/color/autocolor

    63 const TInt KParaBottomBorder=KParaTopBorder;

    64 const TInt KParaLeftBorder=KParaTopBorder;

    65 const TInt KParaRightBorder=KParaTopBorder;

    66 const TInt KParaBullet=KVariableLengthAttribute;

    67 const TInt KParaDefaultTabWidth=sizeof(TUint32);

    68 const TInt KParaTabStop=KTabPosition+KTabType;

    69 const TInt KParaFillSystemColor=sizeof(TUint8);

    70 const TInt KParaBulletSystemColor=sizeof(TUint8);

    71 const TInt KParaTopBorderSystemColor=sizeof(TUint8);

    72 const TInt KParaBottomBorderSystemColor=sizeof(TUint8);

    73 const TInt KParaLeftBorderSystemColor=sizeof(TUint8);

    74 const TInt KParaRightBorderSystemColor=sizeof(TUint8);

    75 const TInt KParaLanguageX=sizeof(TInt32);

    76 const TInt KParaBulletX=sizeof(TInt32) + 2;

    77 const TInt KBitmapType=sizeof(TUint8);

    78 

    79 // Character format attributes

    80 const TInt KCharLanguage=sizeof(TUint8);

    81 const TInt KCharColor=KColor;

    82 const TInt KCharHighlightColor=KColor;

    83 const TInt KCharHighlightStyle=sizeof(TUint8);

    84 const TInt KCharStrikethrough=sizeof(TUint8);

    85 const TInt KCharUnderline=sizeof(TUint8);

    86 const TInt KCharStrokeWeight=sizeof(TUint8);

    87 const TInt KCharPosture=sizeof(TUint8);

    88 const TInt KCharPrintPos=sizeof(TUint8);

    89 const TInt KCharFontHeight=KFontHeight;

    90 const TInt KCharTypeface=KVariableLengthAttribute;

    91 const TInt KCharHiddenText=sizeof(TUint8);

    92 const TInt KCharPictureAlignment=sizeof(TUint8);

    93 const TInt KCharTextSystemColor=sizeof(TUint8);

    94 const TInt KCharFontHighlightSystemColor=sizeof(TUint8);

    95 const TInt KCharLanguageX=sizeof(TInt32);

    96 const TInt KCharParserTag=sizeof(TUint32);

    97 

    98 /*

    99 Lookup table indexed by TTextFormatAttribute enumerated constants.

   100 Specifies the length in bytes of the format attributes.

   101 */

   102 static const TInt8 TheAttributeLength[EAttributeCount] =

   103 	{

   104 	// Paragraph attribute value lengths.	

   105 	KParaLanguage,

   106 	KParaFillColor,

   107 	KParaLeftMargin,

   108 	KParaRightMargin,

   109 	KParaIndent,

   110 	KParaAlignment,

   111 	KParaVerticalAlignment,

   112 	KParaLineSpacing,

   113 	KParaLineSpacingControl,

   114 	KParaSpaceBefore,

   115 	KParaSpaceAfter,

   116 	KParaKeepTogether,

   117 	KParaKeepWithNext,

   118 	KParaStartNewPage,

   119 	KParaWidowOrphan,

   120 	KParaWrap,

   121 	KParaBorderMargin,

   122 	KParaTopBorder,

   123 	KParaBottomBorder,

   124 	KParaLeftBorder,

   125 	KParaRightBorder,

   126 	KParaBullet,

   127 	KParaDefaultTabWidth,

   128 	KParaTabStop,

   129 

   130 	// Character attribute value lengths.

   131 	KCharLanguage,

   132 	KCharColor,

   133 	KCharHighlightColor,

   134 	KCharHighlightStyle,

   135 	KCharFontHeight,

   136 	KCharStrikethrough,

   137 	KCharUnderline,

   138 	KCharStrokeWeight,

   139 	KCharPosture,

   140 	KCharPrintPos,

   141 	KCharTypeface,

   142 	KCharHiddenText,

   143 	KCharPictureAlignment,

   144 

   145 	// Lengths of extended attributes.

   146 	KParaFillSystemColor,

   147 	KParaBulletSystemColor,

   148 	KParaTopBorderSystemColor,

   149 	KParaBottomBorderSystemColor,

   150 	KParaLeftBorderSystemColor,

   151 	KParaRightBorderSystemColor,

   152 	KCharTextSystemColor,

   153 	KCharFontHighlightSystemColor,

   154 	KParaLanguageX,

   155 	KCharLanguageX,

   156 	KParaBulletX,

   157     KBitmapType,

   158 

   159 	// Lengths of internal attributes

   160 	KCharParserTag

   161 	};

   162 

   163 

   164 DLLEXPORT_C void RFormatStream::__DbgTestInvariant()const

   165 // Provides class invariants.

   166 // This class invariant checks the integrity of a completed format stream.

   167 // As such, this invariant is only called by those methods that act upon a completed

   168 // format stream; that is, not the set methods, since the format stream will not be complete until

   169 // this call has completed.

   170 //

   171 	{

   172 #ifdef _DEBUG

   173 		__ASSERT_DEBUG(DoInvariantCheck(),User::Invariant());

   174 #endif

   175 	}

   176 

   177 void RFormatStream::TestInvariantL()const

   178 // Provides class invariants.

   179 // This class invariant checks the integrity of a completed format stream.

   180 // As such, this invariant is only called by those methods that act upon a completed

   181 // format stream; that is, not the set methods, since the format stream will not be complete until

   182 // this call has completed.

   183 //

   184 	{

   185 	if (!DoInvariantCheck())

   186 		User::Leave(KErrCorrupt);

   187 	}

   188 

   189 TBool RFormatStream::DoInvariantCheck() const

   190 // Provides class invariants.

   191 // This class invariant checks the integrity of a completed format stream.

   192 // As such, this invariant is only called by those methods that act upon a completed

   193 // format stream; that is, not the set methods, since the format stream will not be complete until

   194 // this call has completed.

   195 //

   196 	{

   197 	if (!iBase)

   198 		return ETrue;

   199 	if (iEnd>iBase)

   200 		{// Assert: stream is self consistent

   201 		// Walks through the stream (aBuffer), checking that it is in a consistent state.

   202 		// (1) All entries in the buffer conform to a TYPE-VALUE structure, checking that

   203 		// types do not occur in contiguous bytes.  ie there is a value.

   204 		// (2) Checks that all encountered types are valid types.

   205 		// (3) Checks that the buffer has not changed size as a result of this check

   206 		// (4) Checks that all attributes in the stream occur only once.  Done by taking a register

   207 		// as each attribute is read from the stream.  (The exception to this rule are Tab identifiers

   208 		// which, if present, will typically occur several times in the stream).

   209 		//

   210 		enum {ENotPresent,EPresent};

   211 		TInt8 attributeRegister[EAttributeCount];

   212 		for (TInt offset=0;offset<EAttributeCount;offset++)

   213 			{// Mark attributeRegister as all absent

   214 			attributeRegister[offset]=(TInt8)ENotPresent;  // clear all items in the register

   215 			}

   216 		TUint8* tempStreamLoc=iBase;

   217 		TUint8* streamLoc=iBase;

   218 		TUint8* endOfStreamLoc=iEnd;

   219 		TUint8 data=0;

   220 		while (streamLoc<endOfStreamLoc)

   221 			{

   222 			data=*streamLoc;

   223 			streamLoc++;

   224 // Assert: data read is a valid format attribute type.

   225 			if (!(data<((TUint8)EAttributeCount))) return EFalse;

   226 			if (data!=EAttTabStop)

   227 				{// Tab Identifiers can occur multiple times in a stream!!

   228 // Assert: attribute type does not already exist in attributeRegister.

   229 				if (!(attributeRegister[data]!=(TInt8)EPresent)) return EFalse;

   230 				}

   231 			attributeRegister[data]=(TInt8)EPresent;

   232 			tempStreamLoc=streamLoc+Length(streamLoc,(TTextFormatAttribute)data);

   233 			if (!(tempStreamLoc>=streamLoc)) return EFalse;

   234 			streamLoc=tempStreamLoc;

   235 			}

   236 // Assert: everything is still the same size.

   237 		if (!(streamLoc==endOfStreamLoc)) return EFalse;

   238 		}

   239 	return ETrue;

   240 	}

   241 

   242 static inline TUint32 Read32(const TUint8* aPtr)

   243 	{

   244 	TUint32 val = aPtr[0];

   245 	val |= aPtr[1] << 8;

   246 	val |= aPtr[2] << 16;

   247 	val |= aPtr[3] << 24;

   248 	return val;

   249 	}

   250 

   251 

   252 static inline void Write32(TUint8*& aPtr,TUint32 aVal)

   253 	{

   254 	*aPtr++ = TUint8(aVal);

   255 	*aPtr++ = TUint8(aVal >> 8);

   256 	*aPtr++ = TUint8(aVal >> 16);

   257 	*aPtr++ = TUint8(aVal >> 24);

   258 	}

   259 

   260 

   261 RFormatStream::RFormatStream():

   262 	iBase(NULL),

   263 	iEnd(NULL)

   264 	{

   265 	}

   266 

   267 		

   268 // Allocate the buffer

   269 void RFormatStream::AllocL(TInt aSize)

   270 	{

   271     TUint8* pT = reinterpret_cast<TUint8*>(User::ReAllocL(iBase, aSize));

   272     

   273     iBase=pT;

   274     iEnd=pT+aSize;

   275 	}

   276 

   277 

   278 void RFormatStream::Reset()

   279 // Free all storage

   280 //

   281 	{

   282 	if (iBase)

   283 		{

   284 		User::Free(iBase);

   285 		iBase = iEnd = NULL;

   286 		}

   287 	}

   288 

   289 

   290 void RFormatStream::CopyL(const RFormatStream& aSource)

   291 	{

   292 	TInt size = aSource.iEnd - aSource.iBase;

   293 	__ASSERT_DEBUG(size >= 0,Panic(EDebug));

   294 	if (size == 0)

   295 		Reset();

   296 	else

   297 		{

   298 		AllocL(size);

   299 		Mem::Copy(iBase,aSource.iBase,size);

   300 		}

   301 	}

   302 

   303 

   304 /*

   305 Write the bytecode to a stream. Don't write internal attributes; these are not part of the stored format,

   306 but are used for transitory marking of text by URL parsers, etc.

   307 */

   308 void RFormatStream::ExternalizeL(RWriteStream& aStream) const

   309 	{

   310 	__TEST_INVARIANT;

   311 	

   312 	const TUint8* base=iBase;

   313 	if (base)

   314 		{

   315 		const TUint8* end = base;

   316 		while (end < iEnd && *end < EExternalizedAttributeCount)

   317 			{

   318 			int bytes = TheAttributeLength[*end++];

   319 			if (bytes == 0)

   320 				bytes = *end++;

   321 			end += bytes;

   322 			}

   323 		int length = end - base;

   324 		aStream.WriteInt32L(length);

   325 		aStream.WriteL(base,length);

   326 		}

   327 	else

   328 		aStream.WriteInt32L(0);

   329 	}

   330 

   331 

   332 void RFormatStream::InternalizeL(RReadStream& aStream)

   333 // Load the buffer from the specified stream

   334 //

   335 	{

   336 	TestInvariantL();

   337 

   338 	TInt length=aStream.ReadInt32L();

   339 	//

   340 	if (length<0 || length>KMaxFormatStreamLength)

   341 		User::Leave(KErrCorrupt);

   342 	//

   343 	if (length==0)

   344 		Reset();

   345 	else

   346 		{

   347 		AllocL(length);

   348 		aStream.ReadL(iBase,length);

   349 		}

   350 

   351 	TestInvariantL();

   352 	}

   353 

   354 

   355 // Return a pointer to the stored bytecode and put its length in bytes in aLength.

   356 const TUint8* RFormatStream::Ptr(TInt& aLength) const

   357 	{

   358 	__TEST_INVARIANT;

   359 	aLength=iEnd-iBase;

   360 	__ASSERT_DEBUG((iBase==NULL && aLength==0) || (iBase!=NULL && aLength>0),Panic(ECorruptFormatLayer));

   361 	return iBase;

   362 	}

   363 

   364 

   365 // Save the attributes of aCharFormat specified by the corresponding mask aMask.

   366 void RFormatStream::SetCharFormatL(const TCharFormatX& aCharFormatX,const TCharFormatXMask& aMask)

   367 	{

   368 	TInt size=DoCalcSizeCharFormat(aCharFormatX,aMask);

   369 	if (size==0)

   370 		Reset();

   371 	else

   372 		{

   373 		AllocL(size);  // delete the current contents, after allocing a temporary

   374 		DoStoreCharFormat(aCharFormatX,aMask);

   375 		}

   376 

   377 	__TEST_INVARIANT;

   378 	}

   379 

   380 

   381 void RFormatStream::SetParaFormatL(const CParaFormat& aDesiredFormat,const TParaFormatMask& aDesiredMask,

   382 											const CParaFormat& aCurrentFormat)

   383 // Sets the format layer with the specified paragraph format attributes.

   384 // If a leave occurs at any stage, then revert back to original state, and

   385 // propagate the leave.

   386 //

   387 	{

   388 	TInt size=DoCalcSizeParaFormat(aDesiredFormat,aDesiredMask,aCurrentFormat);

   389 	if (size==0)

   390 		Reset();

   391 	else

   392 		{

   393 		AllocL(size);  // delete the current contents, after allocing a temporary

   394 		DoSetParaFormat(aDesiredFormat,aDesiredMask,aCurrentFormat);

   395 		}

   396 

   397 	__TEST_INVARIANT;

   398 	}

   399 	

   400 // Write an auxiliary attribute for a system colour byte. Update aPtr.

   401 static void WriteSystemColor(TUint8*& aPtr,TTextFormatNonMaskableAttribute aAttrib,const TLogicalRgb& aColor)

   402 	{

   403 	TUint8 index = (TUint8)aColor.SystemColorIndex();

   404 	if (index)

   405 		{

   406 		*aPtr++ = TUint8(aAttrib);

   407 		*aPtr++ = index;

   408 		}

   409 	}

   410 

   411 

   412 // Read a system colour byte into a logical colour. Don't change aPtr.

   413 static void ReadSystemColor(const TUint8* aPtr,TLogicalRgb& aColor)

   414 	{

   415 	TUint index = *aPtr;

   416 	aColor.SetSystemColorIndex(index); 

   417 	}

   418 

   419 

   420 // Write paragraph attributes specified by aDesiredMask from aDesiredFormat to the stream.

   421 void RFormatStream::DoSetParaFormat(const CParaFormat& aDesiredFormat,

   422 									TParaFormatMask aMask,

   423 									const CParaFormat& aCurrentFormat)

   424 	{

   425 	TUint8* ptr=iBase;

   426 	if (aMask.AttribIsSet(EAttFillColor))

   427 		{

   428 		*ptr++=TUint8(EAttFillColor);

   429 		ptr=Store(ptr,aDesiredFormat.iFillColor);

   430 		}

   431 	if (aMask.AttribIsSet(EAttLeftMargin))

   432 		{

   433 		*ptr++=TUint8(EAttLeftMargin);

   434 		Write32(ptr,aDesiredFormat.iLeftMarginInTwips);

   435 		}

   436 	if (aMask.AttribIsSet(EAttRightMargin))

   437 		{

   438 		*ptr++=TUint8(EAttRightMargin);

   439 		Write32(ptr,aDesiredFormat.iRightMarginInTwips);

   440 		}

   441 	if (aMask.AttribIsSet(EAttIndent))

   442 		{

   443 		*ptr++=TUint8(EAttIndent);

   444 		Write32(ptr,aDesiredFormat.iIndentInTwips);

   445 		}

   446 	if (aMask.AttribIsSet(EAttAlignment))

   447 		{

   448 		*ptr++=TUint8(EAttAlignment);

   449 		*ptr++=TUint8(aDesiredFormat.iHorizontalAlignment);

   450 		}

   451 	if (aMask.AttribIsSet(EAttVerticalAlignment))

   452 		{

   453 		*ptr++=TUint8(EAttVerticalAlignment);

   454 		*ptr++=TUint8(aDesiredFormat.iVerticalAlignment);

   455 		}

   456 	if (aMask.AttribIsSet(EAttLineSpacing))

   457 		{

   458 		*ptr++=TUint8(EAttLineSpacing);

   459 		Write32(ptr,aDesiredFormat.iLineSpacingInTwips);

   460 		}

   461 	if (aMask.AttribIsSet(EAttLineSpacingControl))

   462 		{

   463 		*ptr++=TUint8(EAttLineSpacingControl);

   464 		*ptr++=TUint8(aDesiredFormat.iLineSpacingControl);

   465 		}

   466 	if (aMask.AttribIsSet(EAttSpaceBefore))

   467 		{

   468 		*ptr++=TUint8(EAttSpaceBefore);

   469 		Write32(ptr,aDesiredFormat.iSpaceBeforeInTwips);

   470 		}

   471 	if (aMask.AttribIsSet(EAttSpaceAfter))

   472 		{

   473 		*ptr++=TUint8(EAttSpaceAfter);

   474 		Write32(ptr,aDesiredFormat.iSpaceAfterInTwips);

   475 		}

   476 	if (aMask.AttribIsSet(EAttKeepTogether))

   477 		{

   478 		*ptr++=TUint8(EAttKeepTogether);

   479 		*ptr++=TUint8(aDesiredFormat.iKeepTogether!=EFalse);

   480 		}

   481 	if (aMask.AttribIsSet(EAttKeepWithNext))

   482 		{

   483 		*ptr++=TUint8(EAttKeepWithNext);

   484 		*ptr++=TUint8(aDesiredFormat.iKeepWithNext!=EFalse);

   485 		}

   486 	if (aMask.AttribIsSet(EAttStartNewPage))

   487 		{

   488 		*ptr++=TUint8(EAttStartNewPage);

   489 		*ptr++=TUint8(aDesiredFormat.iStartNewPage!=EFalse);

   490 		}

   491 	if (aMask.AttribIsSet(EAttWidowOrphan))

   492 		{

   493 		*ptr++=TUint8(EAttWidowOrphan);

   494 		*ptr++=TUint8(aDesiredFormat.iWidowOrphan!=EFalse);

   495 		}

   496 	if (aMask.AttribIsSet(EAttWrap))

   497 		{

   498 		*ptr++=TUint8(EAttWrap);

   499 		*ptr++=TUint8(aDesiredFormat.iWrap!=EFalse);

   500 		}

   501 	if (aMask.AttribIsSet(EAttBorderMargin))

   502 		{

   503 		*ptr++=TUint8(EAttBorderMargin);

   504 		Write32(ptr,aDesiredFormat.iBorderMarginInTwips);

   505 		}

   506 	if ( aDesiredFormat.BordersPresent() || aCurrentFormat.BordersPresent() )

   507 		{

   508 		if (aMask.AttribIsSet(EAttTopBorder))

   509 			ptr=StoreBorder(ptr,EAttTopBorder,aDesiredFormat.ParaBorder(CParaFormat::EParaBorderTop));

   510 		if (aMask.AttribIsSet(EAttBottomBorder))

   511 			ptr=StoreBorder(ptr,EAttBottomBorder,aDesiredFormat.ParaBorder(CParaFormat::EParaBorderBottom));

   512 		if (aMask.AttribIsSet(EAttLeftBorder))

   513 			ptr=StoreBorder(ptr,EAttLeftBorder,aDesiredFormat.ParaBorder(CParaFormat::EParaBorderLeft));

   514 		if (aMask.AttribIsSet(EAttRightBorder))

   515 			ptr=StoreBorder(ptr,EAttRightBorder,aDesiredFormat.ParaBorder(CParaFormat::EParaBorderRight));

   516 		}

   517 	if (aMask.AttribIsSet(EAttDefaultTabWidth))

   518 		{

   519 		*ptr++=TUint8(EAttDefaultTabWidth);

   520 		Write32(ptr,aDesiredFormat.iDefaultTabWidthInTwips);

   521 		}

   522 	if (aMask.AttribIsSet(EAttTabStop))

   523 		{

   524 		TUint8* tptr=ptr;	// prevent stacking of ptr;

   525 		StoreTabs(tptr,aDesiredFormat,aCurrentFormat,ETrue);

   526 		ptr=tptr;

   527 		}

   528 	if (aMask.AttribIsSet(EAttBullet))

   529 		{

   530 		if (aDesiredFormat.iBullet || aCurrentFormat.iBullet)

   531 			{

   532 			if (aDesiredFormat.iBullet)

   533 				ptr = StoreBullet(ptr,*aDesiredFormat.iBullet);

   534 			else if (aCurrentFormat.iBullet)

   535 				ptr = StoreBullet(ptr,TBullet());

   536 			}

   537 		}

   538 	if (!(aDesiredFormat.iLanguage & ~0xFF) && aMask.AttribIsSet(EAttParaLanguage))

   539 		{

   540 		*ptr++=TUint8(EAttParaLanguage);

   541 		*ptr++=TUint8(aDesiredFormat.iLanguage);

   542 		}

   543 

   544 	/*

   545 	Write the auxiliary attributes for system colours, language codes greater than 255, etc.

   546 	These must go at the end of the stream because they will not be recognised by earlier versions

   547 	of ETEXT and will prevent any further attributes from being read.

   548 	*/

   549 	if (aMask.AttribIsSet(EAttFillColor))

   550 		WriteSystemColor(ptr,EAttFillSystemColor,aDesiredFormat.iFillColor);

   551 	if (aMask.AttribIsSet(EAttBullet))

   552 		{

   553 		if (aDesiredFormat.iBullet)

   554 			WriteSystemColor(ptr,EAttBulletSystemColor,aDesiredFormat.iBullet->iColor);

   555 		else if (aCurrentFormat.iBullet)

   556 			WriteSystemColor(ptr,EAttBulletSystemColor,TBullet().iColor);

   557 		}

   558 	if (aDesiredFormat.BordersPresent())

   559 		{

   560 		if (aMask.AttribIsSet(EAttTopBorder))

   561 			WriteSystemColor(ptr,EAttTopBorderSystemColor,aDesiredFormat.ParaBorder(CParaFormat::EParaBorderTop).iColor);

   562 		if (aMask.AttribIsSet(EAttBottomBorder))

   563 			WriteSystemColor(ptr,EAttBottomBorderSystemColor,aDesiredFormat.ParaBorder(CParaFormat::EParaBorderBottom).iColor);

   564 		if (aMask.AttribIsSet(EAttLeftBorder))

   565 			WriteSystemColor(ptr,EAttLeftBorderSystemColor,aDesiredFormat.ParaBorder(CParaFormat::EParaBorderLeft).iColor);

   566 		if (aMask.AttribIsSet(EAttRightBorder))

   567 			WriteSystemColor(ptr,EAttRightBorderSystemColor,aDesiredFormat.ParaBorder(CParaFormat::EParaBorderRight).iColor);

   568 		}

   569 	if ((aDesiredFormat.iLanguage & ~0xFF) && aMask.AttribIsSet(EAttParaLanguage))

   570 		{

   571 		*ptr++ = TUint8(EAttParaLanguageX);

   572 		Write32(ptr,aDesiredFormat.iLanguage);

   573 		}

   574 	if (aMask.AttribIsSet(EAttBullet))

   575 		{

   576 		if (aDesiredFormat.iBullet || aCurrentFormat.iBullet)

   577 			{

   578 			TBullet bullet;

   579 			const TBullet* b = aDesiredFormat.iBullet;

   580 			if (!b)

   581 				b = •

   582 			*ptr++ = TUint8(EAttBulletX);

   583 			*ptr++ = TUint8(b->iStyle);

   584 			Write32(ptr,b->iStartNumber);

   585 			*ptr++ = TUint8(b->iAlignment);

   586 			}

   587 		}

   588 	}

   589 

   590 

   591 TInt RFormatStream::DoCalcSizeParaFormat(const CParaFormat& aDesiredFormat,TParaFormatMask aMask,

   592 										 const CParaFormat& aCurrentFormat)

   593 // determine the amount of memory required to store the

   594 // specified attriubutes from the specified paragraph format.

   595 //

   596 	{

   597 	TInt size=0;

   598 	if (aMask.AttribIsSet(EAttFillColor))

   599 		{

   600 		size+=(KTypeSize+KParaFillColor);

   601 		if (aDesiredFormat.iFillColor.SystemColorIndex())

   602 			size += KTypeSize + KParaFillSystemColor;

   603 		}

   604 	if (aMask.AttribIsSet(EAttLeftMargin))

   605 		size+=(KTypeSize+KParaLeftMargin);

   606 	if (aMask.AttribIsSet(EAttRightMargin))

   607 		size+=(KTypeSize+KParaRightMargin);

   608 	if (aMask.AttribIsSet(EAttIndent))

   609 		size+=(KTypeSize+KParaIndent);

   610 	if (aMask.AttribIsSet(EAttAlignment))

   611 		size+=(KTypeSize+KParaAlignment);

   612 	if (aMask.AttribIsSet(EAttVerticalAlignment))

   613 		size+=(KTypeSize+KParaVerticalAlignment);

   614 	if (aMask.AttribIsSet(EAttLineSpacing))

   615 		size+=(KTypeSize+KParaLineSpacing);

   616 	if (aMask.AttribIsSet(EAttLineSpacingControl))

   617 		size+=(KTypeSize+KParaLineSpacingControl);

   618 	if (aMask.AttribIsSet(EAttSpaceBefore))

   619 		size+=(KTypeSize+KParaSpaceBefore);

   620 	if (aMask.AttribIsSet(EAttSpaceAfter))

   621 		size+=(KTypeSize+KParaSpaceAfter);

   622 	if (aMask.AttribIsSet(EAttKeepTogether))

   623 		size+=(KTypeSize+KParaKeepTogether);

   624 	if (aMask.AttribIsSet(EAttKeepWithNext))

   625 		size+=(KTypeSize+KParaKeepWithNext);

   626 	if (aMask.AttribIsSet(EAttStartNewPage))

   627 		size+=(KTypeSize+KParaStartNewPage);

   628 	if (aMask.AttribIsSet(EAttWidowOrphan))

   629 		size+=(KTypeSize+KParaWidowOrphan);

   630 	if (aMask.AttribIsSet(EAttWrap))

   631 		size+=(KTypeSize+KParaWrap);

   632 	if (aMask.AttribIsSet(EAttBorderMargin))

   633 		size+=(KTypeSize+KParaBorderMargin);

   634 	if ( aDesiredFormat.BordersPresent() || aCurrentFormat.BordersPresent() )

   635 		{

   636 		if (aMask.AttribIsSet(EAttTopBorder))

   637 			{

   638 			size+=(KTypeSize+

   639 			sizeof(TUint8)+  // line style

   640 			sizeof(TInt32)+  // line thickness

   641 			KColor+

   642 			sizeof(TUint8));  // auto color flag

   643 			if (aDesiredFormat.ParaBorder(CParaFormat::EParaBorderTop).iColor.SystemColorIndex())

   644 				size += KTypeSize + KParaTopBorderSystemColor;

   645 			}

   646 		if (aMask.AttribIsSet(EAttBottomBorder))

   647 			{

   648 			size+=(KTypeSize+

   649 			sizeof(TUint8)+  // line style

   650 			sizeof(TInt32)+  // line thickness

   651 			KColor+

   652 			sizeof(TUint8));  // auto color flag

   653 			if (aDesiredFormat.ParaBorder(CParaFormat::EParaBorderBottom).iColor.SystemColorIndex())

   654 				size += KTypeSize + KParaBottomBorderSystemColor;

   655 			}

   656 		if (aMask.AttribIsSet(EAttLeftBorder))

   657 			{

   658 			size+=(KTypeSize+

   659 			sizeof(TUint8)+  // line style

   660 			sizeof(TInt32)+  // line thickness

   661 			KColor+

   662 			sizeof(TUint8));  // auto color flag

   663 			if (aDesiredFormat.ParaBorder(CParaFormat::EParaBorderLeft).iColor.SystemColorIndex())

   664 				size += KTypeSize + KParaLeftBorderSystemColor;

   665 			}

   666 		if (aMask.AttribIsSet(EAttRightBorder))

   667 			{

   668 			size+=(KTypeSize+

   669 			sizeof(TUint8)+  // line style

   670 			sizeof(TInt32)+  // line thickness

   671 			KColor+

   672 			sizeof(TUint8));  // auto color flag

   673 			if (aDesiredFormat.ParaBorder(CParaFormat::EParaBorderRight).iColor.SystemColorIndex())

   674 				size += KTypeSize + KParaBulletSystemColor;

   675 			}

   676 		}

   677 	if (aMask.AttribIsSet(EAttDefaultTabWidth))

   678 		size+=(KTypeSize+KParaDefaultTabWidth);

   679 	if (aMask.AttribIsSet(EAttTabStop))

   680 		{

   681 		TUint8* ptr=NULL;

   682 		size+=StoreTabs(ptr,aDesiredFormat,aCurrentFormat,EFalse);

   683 		}

   684 	if (aMask.AttribIsSet(EAttBullet))

   685 		{

   686 		if (aDesiredFormat.iBullet || aCurrentFormat.iBullet)

   687 			{

   688 			size += KTypeSize +

   689 					sizeof(TUint8) +		// length of following data

   690 					sizeof(TText) +			// iCharacterCode

   691 					KFontHeight +			// iHeightInTwips

   692 					sizeof(TUint8) +		// iHanging indent

   693 					KCharColor +			// iColor

   694 					sizeof(TUint8) +		// typeface name size

   695 					KTypefaceFlags;			// typeface flags

   696 

   697 			if (aDesiredFormat.iBullet)

   698 				size += aDesiredFormat.iBullet->iTypeface.iName.Size();  // font name

   699 

   700 			if ((aDesiredFormat.iBullet && aDesiredFormat.iBullet->iColor.SystemColorIndex()) ||

   701 				(aCurrentFormat.iBullet))

   702 				size += KTypeSize + KParaBulletSystemColor;

   703 

   704 			size += KTypeSize + KParaBulletX;

   705 			}

   706 		}

   707 	if (aMask.AttribIsSet(EAttParaLanguage))

   708 		{

   709 		if (aDesiredFormat.iLanguage & ~0xFF)

   710 			size += KTypeSize + KParaLanguageX;

   711 		else

   712 			size += KTypeSize + KParaLanguage;

   713 		}

   714 	return size;

   715 	}

   716 

   717 

   718 // Store the specified values in this (allocated) format stream.

   719 void RFormatStream::DoStoreCharFormat(const TCharFormatX& aCharFormat,TCharFormatXMask aMask)

   720 	{

   721 	TUint8* ptr = iBase;

   722 	const TCharFormat format = aCharFormat.iCharFormat;

   723 

   724 	if (aMask.AttribIsSet(EAttColor))

   725 		{

   726 		*ptr++=TUint8(EAttColor);

   727 		ptr=Store(ptr,format.iFontPresentation.iTextColor);

   728 		}

   729 	if (aMask.AttribIsSet(EAttFontHighlightColor))

   730 		{

   731 		*ptr++=TUint8(EAttFontHighlightColor);

   732 		ptr=Store(ptr,format.iFontPresentation.iHighlightColor);

   733 		}

   734 	if (aMask.AttribIsSet(EAttFontHighlightStyle))

   735 		{

   736 		*ptr++=TUint8(EAttFontHighlightStyle);

   737 		*ptr++=(TUint8)format.iFontPresentation.iHighlightStyle;

   738 		}

   739 	if (aMask.AttribIsSet(EAttFontStrikethrough))

   740 		{

   741 		*ptr++=TUint8(EAttFontStrikethrough);

   742 		*ptr++=(TUint8)format.iFontPresentation.iStrikethrough;

   743 		}

   744 	if (aMask.AttribIsSet(EAttFontUnderline))

   745 		{

   746 		*ptr++=TUint8(EAttFontUnderline);

   747 		*ptr++=(TUint8)format.iFontPresentation.iUnderline;

   748 		}

   749 	if (aMask.AttribIsSet(EAttFontHeight))

   750 		{

   751 		*ptr++=TUint8(EAttFontHeight);

   752 		Write32(ptr,format.iFontSpec.iHeight);

   753 		}

   754 	if (aMask.AttribIsSet(EAttFontPosture))

   755 		{

   756 		*ptr++=TUint8(EAttFontPosture);

   757 		*ptr++=TUint8(format.iFontSpec.iFontStyle.Posture());

   758 		}

   759 	if (aMask.AttribIsSet(EAttFontStrokeWeight))

   760 		{

   761 		*ptr++=TUint8(EAttFontStrokeWeight);

   762 		*ptr++=TUint8(format.iFontSpec.iFontStyle.StrokeWeight());

   763 		}

   764 	if (aMask.AttribIsSet(EAttFontPrintPos))

   765 		{

   766 		*ptr++=TUint8(EAttFontPrintPos);

   767 		*ptr++=TUint8(format.iFontSpec.iFontStyle.PrintPosition());

   768 		}

   769 	if (aMask.AttribIsSet(EAttFontTypeface))

   770 		{

   771 		*ptr++=TUint8(EAttFontTypeface);

   772 		ptr=Store(ptr,format.iFontSpec.iTypeface);

   773 		*ptr++=TUint8(EAttBitmapType);

   774 		*ptr++=TUint8(format.iFontSpec.iFontStyle.BitmapType());

   775 		}

   776 	if (!(format.iLanguage & ~0xFF) && aMask.AttribIsSet(EAttCharLanguage))

   777 		{

   778 		*ptr++=TUint8(EAttCharLanguage);

   779 		*ptr++=TUint8(format.iLanguage);

   780 		}

   781 	if (aMask.AttribIsSet(EAttFontHiddenText))

   782 		{

   783 		*ptr++=TUint8(EAttFontHiddenText);

   784 		*ptr++=TUint8(format.iFontPresentation.iHiddenText!=EFalse);

   785 		}

   786 	if (aMask.AttribIsSet(EAttFontPictureAlignment))

   787 		{

   788 		*ptr++=TUint8(EAttFontPictureAlignment);

   789 		*ptr++=TUint8(format.iFontPresentation.iPictureAlignment);

   790 		}

   791 

   792 	// Auxiliary attributes for system colours, etc.

   793 	if (aMask.AttribIsSet(EAttColor))

   794 		WriteSystemColor(ptr,EAttTextSystemColor,format.iFontPresentation.iTextColor);

   795 	if (aMask.AttribIsSet(EAttFontHighlightColor))

   796 		WriteSystemColor(ptr,EAttFontHighlightSystemColor,format.iFontPresentation.iHighlightColor);

   797 	if ((format.iLanguage & ~0xFF) && aMask.AttribIsSet(EAttCharLanguage))

   798 		{

   799 		*ptr++ = TUint8(EAttCharLanguageX);

   800 		Write32(ptr,format.iLanguage);

   801 		}

   802 

   803 	// Internal character attributes:

   804 	if (aMask.AttribIsSet(EAttParserTag))

   805 		{

   806 		*ptr++ = TUint8(EAttParserTag);

   807 		Write32(ptr,aCharFormat.iParserTag);

   808 		}

   809 	}

   810 

   811 

   812 TInt RFormatStream::DoCalcSizeCharFormat(const TCharFormatX& aCharFormatX,const TCharFormatXMask& aMask)

   813 	{

   814 	TInt size = 0;

   815 	const TCharFormat format = aCharFormatX.iCharFormat;

   816 

   817 	if (aMask.AttribIsSet(EAttColor))

   818 		{

   819 		size+=(KTypeSize+KCharColor);

   820 		if (format.iFontPresentation.iTextColor.SystemColorIndex())

   821 			size += KTypeSize + KCharTextSystemColor;

   822 		}

   823 	if (aMask.AttribIsSet(EAttFontHighlightColor))

   824 		{

   825 		size+=(KTypeSize+KCharHighlightColor);

   826 		if (format.iFontPresentation.iHighlightColor.SystemColorIndex())

   827 			size += KTypeSize + KCharFontHighlightSystemColor;

   828 		}

   829 	if (aMask.AttribIsSet(EAttFontHighlightStyle))

   830 		size+=(KTypeSize+KCharHighlightStyle);

   831 	if (aMask.AttribIsSet(EAttFontStrikethrough))

   832 		size+=(KTypeSize+KCharStrikethrough);

   833 	if (aMask.AttribIsSet(EAttFontUnderline))

   834 		size+=(KTypeSize+KCharUnderline);

   835 	if (aMask.AttribIsSet(EAttFontHeight))

   836 		size+=(KTypeSize+KCharFontHeight);

   837 	if (aMask.AttribIsSet(EAttFontPosture))

   838 		size+=(KTypeSize+KCharPosture);

   839 	if (aMask.AttribIsSet(EAttFontStrokeWeight))

   840 		size+=(KTypeSize+KCharStrokeWeight);

   841 	if (aMask.AttribIsSet(EAttFontPrintPos))

   842 		size+=(KTypeSize+KCharPrintPos);

   843 	if (aMask.AttribIsSet(EAttFontTypeface))

   844 		{

   845 		TUint8 length=(TUint8)format.iFontSpec.iTypeface.iName.Size();

   846 		size+=(KTypeSize+sizeof(TUint8)+length+sizeof(TUint8));  // size in bytes

   847 		size+=(KTypeSize+KBitmapType);

   848 		}

   849 	if (aMask.AttribIsSet(EAttCharLanguage))

   850 		{

   851 		if (format.iLanguage & ~0xFF)

   852 			size += KTypeSize + KCharLanguageX;

   853 		else

   854 			size += KTypeSize + KCharLanguage;

   855 		}

   856 	if (aMask.AttribIsSet(EAttFontHiddenText))

   857 		size+=(KTypeSize+KCharHiddenText);

   858 	if (aMask.AttribIsSet(EAttFontPictureAlignment))

   859 		size+=(KTypeSize+KCharPictureAlignment);

   860 

   861 	// Internal character attributes

   862 	if (aMask.AttribIsSet(EAttParserTag))

   863 		size += KTypeSize + KCharParserTag;

   864 	

   865 	return size;

   866 	}

   867 

   868 void RFormatStream::RemoveRedundantCharFormat(TCharFormatMask& aMask,

   869 											  const TCharFormatX& aFormat,const TCharFormatX& aEffectiveFormat)

   870 	{

   871 	TCharFormatXMask mask = aMask;

   872 	const TCharFormat format = aFormat.iCharFormat;

   873 	const TCharFormat effective_format = aEffectiveFormat.iCharFormat;

   874 

   875 	if (mask.AttribIsSet(EAttColor))

   876 		{

   877 		if (format.iFontPresentation.iTextColor==effective_format.iFontPresentation.iTextColor)

   878 			mask.ClearAttrib(EAttColor);

   879 		}

   880 	if (mask.AttribIsSet(EAttFontHighlightColor))

   881 		{

   882 		if (format.iFontPresentation.iHighlightColor==effective_format.iFontPresentation.iHighlightColor)

   883 			mask.ClearAttrib(EAttFontHighlightColor);

   884 		}

   885 	if (mask.AttribIsSet(EAttFontHighlightStyle))

   886 		{

   887 		if (format.iFontPresentation.iHighlightStyle==effective_format.iFontPresentation.iHighlightStyle)

   888 			mask.ClearAttrib(EAttFontHighlightStyle);

   889 		}

   890 	if (mask.AttribIsSet(EAttFontStrikethrough))

   891 		{

   892 		if (format.iFontPresentation.iStrikethrough==effective_format.iFontPresentation.iStrikethrough)

   893 			mask.ClearAttrib(EAttFontStrikethrough);

   894 		}

   895 	if (mask.AttribIsSet(EAttFontUnderline))

   896 		{

   897 		if (format.iFontPresentation.iUnderline==effective_format.iFontPresentation.iUnderline)

   898 			mask.ClearAttrib(EAttFontUnderline);

   899 		}

   900 	if (mask.AttribIsSet(EAttFontHeight))

   901 		{

   902 		if (format.iFontSpec.iHeight==effective_format.iFontSpec.iHeight)

   903 			mask.ClearAttrib(EAttFontHeight);

   904 		}

   905 	if (mask.AttribIsSet(EAttFontPosture))

   906 		{

   907 		if (format.iFontSpec.iFontStyle.Posture()==effective_format.iFontSpec.iFontStyle.Posture())

   908 			mask.ClearAttrib(EAttFontPosture);

   909 		}

   910 	if (mask.AttribIsSet(EAttFontStrokeWeight))

   911 		{

   912 		if (format.iFontSpec.iFontStyle.StrokeWeight()==effective_format.iFontSpec.iFontStyle.StrokeWeight())

   913 			mask.ClearAttrib(EAttFontStrokeWeight);

   914 		}

   915 	if (mask.AttribIsSet(EAttFontPrintPos))

   916 		{

   917 		if (format.iFontSpec.iFontStyle.PrintPosition()==effective_format.iFontSpec.iFontStyle.PrintPosition())

   918 			mask.ClearAttrib(EAttFontPrintPos);

   919 		}

   920 	if (mask.AttribIsSet(EAttFontTypeface))

   921 		{

   922 		if (format.iFontSpec.iTypeface==effective_format.iFontSpec.iTypeface)

   923 			mask.ClearAttrib(EAttFontTypeface);

   924 		}

   925 	if (mask.AttribIsSet(EAttCharLanguage))

   926 		{

   927 		if (format.iLanguage==effective_format.iLanguage)

   928 			mask.ClearAttrib(EAttCharLanguage);

   929 		}

   930 	if (mask.AttribIsSet(EAttFontHiddenText))

   931 		{

   932 		if (format.iFontPresentation.iHiddenText==effective_format.iFontPresentation.iHiddenText)

   933 			mask.ClearAttrib(EAttFontHiddenText);

   934 		}

   935 	if (mask.AttribIsSet(EAttFontPictureAlignment))

   936 		{

   937 		if (format.iFontPresentation.iPictureAlignment==effective_format.iFontPresentation.iPictureAlignment)

   938 			mask.ClearAttrib(EAttFontPictureAlignment);

   939 		}

   940 	if (mask.AttribIsSet(EAttParserTag))

   941 		{

   942 		if (aFormat.iParserTag == aEffectiveFormat.iParserTag)

   943 			mask.ClearAttrib(EAttParserTag);

   944 		}

   945 	aMask = mask;

   946 	}

   947 

   948 

   949 void RFormatStream::SenseParaFormatL(CParaFormat& aParaFormat,TParaFormatMask& aMask,CParaFormat::TParaFormatGetMode aMode)const

   950 // Dumps contents of the stream into aParaFormat.  The attributes written to aParaFormat

   951 // are determined by the mode, aMode.

   952 // If the mode is EAllAttributes, then all attributes are written,

   953 // if the mode is EFixedAttributes, then only the fixed atttibutes are written,

   954 // ie, not tabs,borders,bullet (which are variable).

   955 // For each format attribute found in the stream:

   956 // write it into a ParaFormat if the corresponding flag in aMask is not set,

   957 // and set this flag showing the attribute has been written into aParaFormat.

   958 //

   959 // If aMode is EAllAttributes this function may leave through out-of-memory allocating paragraph borders,

   960 // bullets or tabs.

   961 // If aMode is EFixedAttributes, this function is guaranteed not to leave.

   962 //

   963 	{

   964 	__TEST_INVARIANT;

   965 

   966 	TUint8* ptr=iBase;

   967 	if (ptr==NULL)

   968 		return;

   969 	TParaFormatMask old_mask = aMask;

   970 	TParaFormatMask new_mask = aMask;

   971 	TUint8* end=iEnd;

   972 	TParaBorder* b = NULL;

   973 

   974 	while (ptr < end)

   975 		{

   976 		TUint8 type = *ptr;

   977 		ptr += KTypeSize;

   978 		switch (type)

   979 			{

   980 			case EAttFillColor:

   981 				if (!old_mask.AttribIsSet(EAttFillColor))

   982 					{

   983 					new_mask.SetAttrib(EAttFillColor);

   984 					ptr=ReadValue(ptr,aParaFormat.iFillColor);

   985 					}

   986 				else

   987 					ptr+=KParaFillColor;

   988 				break;

   989 			case EAttLeftMargin:

   990 				if (!old_mask.AttribIsSet(EAttLeftMargin))

   991 					{

   992 					new_mask.SetAttrib(EAttLeftMargin);

   993 					aParaFormat.iLeftMarginInTwips = Read32(ptr);

   994 					}

   995 				ptr+=KParaLeftMargin;

   996 				break;

   997 			case EAttRightMargin:

   998 				if (!old_mask.AttribIsSet(EAttRightMargin))

   999 					{

  1000 					new_mask.SetAttrib(EAttRightMargin);

  1001 					aParaFormat.iRightMarginInTwips = Read32(ptr);

  1002 					}

  1003 				ptr+=KParaRightMargin;

  1004 				break;

  1005 			case EAttIndent:

  1006 				if (!old_mask.AttribIsSet(EAttIndent))

  1007 					{

  1008 					new_mask.SetAttrib(EAttIndent);

  1009 					aParaFormat.iIndentInTwips = Read32(ptr);

  1010 					}

  1011 				ptr+=KParaIndent;

  1012 				break;

  1013 			case EAttAlignment:

  1014 				if (!old_mask.AttribIsSet(EAttAlignment))

  1015 					{

  1016 					new_mask.SetAttrib(EAttAlignment);

  1017 					aParaFormat.iHorizontalAlignment=CParaFormat::TAlignment(*ptr);

  1018 					}

  1019 				ptr+=KParaAlignment;

  1020 				break;

  1021 			case EAttVerticalAlignment:

  1022 				if (!old_mask.AttribIsSet(EAttVerticalAlignment))

  1023 					{

  1024 					new_mask.SetAttrib(EAttVerticalAlignment);

  1025 					aParaFormat.iVerticalAlignment=CParaFormat::TAlignment(*ptr);

  1026 					}

  1027 				ptr+=KParaVerticalAlignment;

  1028 				break;

  1029 			case EAttLineSpacing:

  1030 				if (!old_mask.AttribIsSet(EAttLineSpacing))

  1031 					{

  1032 					new_mask.SetAttrib(EAttLineSpacing);

  1033 					aParaFormat.iLineSpacingInTwips = Read32(ptr);

  1034 					}

  1035 				ptr+=KParaLineSpacing;

  1036 				break;

  1037 			case EAttLineSpacingControl:

  1038 				if (!old_mask.AttribIsSet(EAttLineSpacingControl))

  1039 					{

  1040 					new_mask.SetAttrib(EAttLineSpacingControl);

  1041 					aParaFormat.iLineSpacingControl=(CParaFormat::TLineSpacingControl)*ptr;

  1042 					}

  1043 				ptr+=KParaLineSpacingControl;

  1044 				break;

  1045 			case EAttSpaceBefore:

  1046 				if (!old_mask.AttribIsSet(EAttSpaceBefore))

  1047 					{

  1048 					new_mask.SetAttrib(EAttSpaceBefore);

  1049 					aParaFormat.iSpaceBeforeInTwips = Read32(ptr);

  1050 					}

  1051 				ptr+=KParaSpaceBefore;

  1052 				break;

  1053 			case EAttSpaceAfter:

  1054 				if (!old_mask.AttribIsSet(EAttSpaceAfter))

  1055 					{

  1056 					new_mask.SetAttrib(EAttSpaceAfter);

  1057 					aParaFormat.iSpaceAfterInTwips = Read32(ptr);

  1058 					}

  1059 				ptr+=KParaSpaceAfter;

  1060 				break;

  1061 			case EAttKeepTogether:

  1062 				if (!old_mask.AttribIsSet(EAttKeepTogether))

  1063 					{

  1064 					new_mask.SetAttrib(EAttKeepTogether);

  1065 					aParaFormat.iKeepTogether=TBool(*ptr);

  1066 					}

  1067 				ptr+=KParaKeepTogether;

  1068 				break;

  1069 			case EAttKeepWithNext:

  1070 				if (!old_mask.AttribIsSet(EAttKeepWithNext))

  1071 					{

  1072 					new_mask.SetAttrib(EAttKeepWithNext);

  1073 					aParaFormat.iKeepWithNext=(TBool)*ptr;

  1074 					}

  1075 				ptr+=KParaKeepWithNext;

  1076 				break;

  1077 			case EAttStartNewPage:

  1078 				if (!old_mask.AttribIsSet(EAttStartNewPage))

  1079 					{

  1080 					new_mask.SetAttrib(EAttStartNewPage);

  1081 					aParaFormat.iStartNewPage=TBool(*ptr);

  1082 					}

  1083 				ptr+=KParaStartNewPage;

  1084 				break;

  1085 			case EAttWidowOrphan:

  1086 				if (!old_mask.AttribIsSet(EAttWidowOrphan))

  1087 					{

  1088 					new_mask.SetAttrib(EAttWidowOrphan);

  1089 					aParaFormat.iWidowOrphan=TBool(*ptr);

  1090 					}

  1091 				ptr+=KParaWidowOrphan;

  1092 				break;

  1093 			case EAttWrap:

  1094 				if (!old_mask.AttribIsSet(EAttWrap))

  1095 					{

  1096 					new_mask.SetAttrib(EAttWrap);

  1097 					aParaFormat.iWrap=TBool(*ptr);

  1098 					}

  1099 				ptr+=KParaWrap;

  1100 				break;

  1101 			case EAttBorderMargin:

  1102 				if (!old_mask.AttribIsSet(EAttBorderMargin))

  1103 					{

  1104 					new_mask.SetAttrib(EAttBorderMargin);

  1105 					aParaFormat.iBorderMarginInTwips = Read32(ptr);

  1106 					}

  1107 				ptr+=KParaBorderMargin;

  1108 				break;

  1109 			case EAttTopBorder:

  1110 				if (aMode==CParaFormat::EFixedAttributes || old_mask.AttribIsSet(EAttTopBorder) )

  1111 					{

  1112 					ptr+=KParaTopBorder;

  1113 					}

  1114 				else

  1115 					{

  1116 					TParaBorder border;

  1117 					ptr=ReadValue(ptr,border);

  1118 					aParaFormat.SetParaBorderL(CParaFormat::EParaBorderTop,border);

  1119 					new_mask.SetAttrib(EAttTopBorder);

  1120 					}

  1121 				break;

  1122 			case EAttBottomBorder:

  1123 				if (aMode==CParaFormat::EFixedAttributes || old_mask.AttribIsSet(EAttBottomBorder))

  1124 					{

  1125 					ptr+=KParaBottomBorder;

  1126 					}

  1127 				else

  1128 					{

  1129 					TParaBorder border;

  1130 					ptr=ReadValue(ptr,border);

  1131 					aParaFormat.SetParaBorderL(CParaFormat::EParaBorderBottom,border);

  1132 					new_mask.SetAttrib(EAttBottomBorder);

  1133 					}

  1134 				break;