/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include <e32std.h>

#include <s32strm.h>

#include <s32mem.h>

#include "TXTFRMAT.H"

#include <txtfmstm.h>

#include "TXTSTD.H"

const TInt KMaxFormatStreamLength=0x400;  // 1024 bytes

// Standard attributes

const TUint KFontProportional=0x01;

const TUint KFontSerif=0x02;

const TUint KFontSymbol=0x04;

const TUint KTypefaceFlags=sizeof(TUint8);

const TInt KTypeSize=sizeof(TUint8);

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

const TInt KFontHeight=sizeof(TInt32);

const TInt KParaBorderThickness=sizeof(TInt32);

const TInt KTabPosition=sizeof(TUint32);

const TInt KTabType=sizeof(TUint8);

// Paragraph format attributes

const TInt KVariableLengthAttribute=0;

const TInt KParaLanguage=sizeof(TUint8);

const TInt KParaFillColor=KColor;

const TInt KParaLeftMargin=sizeof(TInt32);

const TInt KParaRightMargin=sizeof(TInt32);

const TInt KParaIndent=sizeof(TInt32);

const TInt KParaAlignment=sizeof(TUint8);

const TInt KParaVerticalAlignment=sizeof(TUint8);

const TInt KParaLineSpacing=sizeof(TInt32);

const TInt KParaLineSpacingControl=sizeof(TUint8);

const TInt KParaSpaceBefore=sizeof(TInt32);

const TInt KParaSpaceAfter=sizeof(TInt32);

const TInt KParaKeepTogether=sizeof(TUint8);

const TInt KParaKeepWithNext=sizeof(TUint8);

const TInt KParaStartNewPage=sizeof(TUint8);

const TInt KParaWidowOrphan=sizeof(TUint8);

const TInt KParaWrap=sizeof(TUint8);

const TInt KParaBorderMargin=sizeof(TInt32);

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

const TInt KParaBottomBorder=KParaTopBorder;

const TInt KParaLeftBorder=KParaTopBorder;

const TInt KParaRightBorder=KParaTopBorder;

const TInt KParaBullet=KVariableLengthAttribute;

const TInt KParaDefaultTabWidth=sizeof(TUint32);

const TInt KParaTabStop=KTabPosition+KTabType;

const TInt KParaFillSystemColor=sizeof(TUint8);

const TInt KParaBulletSystemColor=sizeof(TUint8);

const TInt KParaTopBorderSystemColor=sizeof(TUint8);

const TInt KParaBottomBorderSystemColor=sizeof(TUint8);

const TInt KParaLeftBorderSystemColor=sizeof(TUint8);

const TInt KParaRightBorderSystemColor=sizeof(TUint8);

const TInt KParaLanguageX=sizeof(TInt32);

const TInt KParaBulletX=sizeof(TInt32) + 2;

const TInt KBitmapType=sizeof(TUint8);

// Character format attributes

const TInt KCharLanguage=sizeof(TUint8);

const TInt KCharColor=KColor;

const TInt KCharHighlightColor=KColor;

const TInt KCharHighlightStyle=sizeof(TUint8);

const TInt KCharStrikethrough=sizeof(TUint8);

const TInt KCharUnderline=sizeof(TUint8);

const TInt KCharStrokeWeight=sizeof(TUint8);

const TInt KCharPosture=sizeof(TUint8);

const TInt KCharPrintPos=sizeof(TUint8);

const TInt KCharFontHeight=KFontHeight;

const TInt KCharTypeface=KVariableLengthAttribute;

const TInt KCharHiddenText=sizeof(TUint8);

const TInt KCharPictureAlignment=sizeof(TUint8);

const TInt KCharTextSystemColor=sizeof(TUint8);

const TInt KCharFontHighlightSystemColor=sizeof(TUint8);

const TInt KCharLanguageX=sizeof(TInt32);

const TInt KCharParserTag=sizeof(TUint32);

/*

Lookup table indexed by TTextFormatAttribute enumerated constants.

Specifies the length in bytes of the format attributes.

*/

static const TInt8 TheAttributeLength[EAttributeCount] =

	{

	// Paragraph attribute value lengths.	

	KParaLanguage,

	KParaFillColor,

	KParaLeftMargin,

	KParaRightMargin,

	KParaIndent,

	KParaAlignment,

	KParaVerticalAlignment,

	KParaLineSpacing,

	KParaLineSpacingControl,

	KParaSpaceBefore,

	KParaSpaceAfter,

	KParaKeepTogether,

	KParaKeepWithNext,

	KParaStartNewPage,

	KParaWidowOrphan,

	KParaWrap,

	KParaBorderMargin,

	KParaTopBorder,

	KParaBottomBorder,

	KParaLeftBorder,

	KParaRightBorder,

	KParaBullet,

	KParaDefaultTabWidth,

	KParaTabStop,

	// Character attribute value lengths.

	KCharLanguage,

	KCharColor,

	KCharHighlightColor,

	KCharHighlightStyle,

	KCharFontHeight,

	KCharStrikethrough,

	KCharUnderline,

	KCharStrokeWeight,

	KCharPosture,

	KCharPrintPos,

	KCharTypeface,

	KCharHiddenText,

	KCharPictureAlignment,

	// Lengths of extended attributes.

	KParaFillSystemColor,

	KParaBulletSystemColor,

	KParaTopBorderSystemColor,

	KParaBottomBorderSystemColor,

	KParaLeftBorderSystemColor,

	KParaRightBorderSystemColor,

	KCharTextSystemColor,

	KCharFontHighlightSystemColor,

	KParaLanguageX,

	KCharLanguageX,

	KParaBulletX,

    KBitmapType,

	// Lengths of internal attributes

	KCharParserTag

	};

DLLEXPORT_C void RFormatStream::__DbgTestInvariant()const

// Provides class invariants.

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

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

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

// this call has completed.

//

	{

#ifdef _DEBUG

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

#endif

	}

void RFormatStream::TestInvariantL()const

// Provides class invariants.

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

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

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

// this call has completed.

//

	{

	if (!DoInvariantCheck())

		User::Leave(KErrCorrupt);

	}

TBool RFormatStream::DoInvariantCheck() const

// Provides class invariants.

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

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

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

// this call has completed.

//

	{

	if (!iBase)

		return ETrue;

	if (iEnd>iBase)

		{// Assert: stream is self consistent

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

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

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

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

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

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

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

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

		//

		enum {ENotPresent,EPresent};

		TInt8 attributeRegister[EAttributeCount];

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

			{// Mark attributeRegister as all absent

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

			}

		TUint8* tempStreamLoc=iBase;

		TUint8* streamLoc=iBase;

		TUint8* endOfStreamLoc=iEnd;

		TUint8 data=0;

		while (streamLoc<endOfStreamLoc)

			{

			data=*streamLoc;

			streamLoc++;

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

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

			if (data!=EAttTabStop)

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

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

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

				}

			attributeRegister[data]=(TInt8)EPresent;

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

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

			streamLoc=tempStreamLoc;

			}

// Assert: everything is still the same size.

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

		}

	return ETrue;

	}

static inline TUint32 Read32(const TUint8* aPtr)

	{

	TUint32 val = aPtr[0];

	val |= aPtr[1] << 8;

	val |= aPtr[2] << 16;

	val |= aPtr[3] << 24;

	return val;

	}

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

	{

	*aPtr++ = TUint8(aVal);

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

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

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

	}

RFormatStream::RFormatStream():

	iBase(NULL),

	iEnd(NULL)

	{

	}

// Allocate the buffer

void RFormatStream::AllocL(TInt aSize)

	{

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

    iBase=pT;

    iEnd=pT+aSize;

	}

void RFormatStream::Reset()

// Free all storage

//

	{

	if (iBase)

		{

		User::Free(iBase);

		iBase = iEnd = NULL;

		}

	}

void RFormatStream::CopyL(const RFormatStream& aSource)

	{

	TInt size = aSource.iEnd - aSource.iBase;

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

	if (size == 0)

		Reset();

	else

		{

		AllocL(size);

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

		}

	}

/*

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

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

*/

void RFormatStream::ExternalizeL(RWriteStream& aStream) const

	{

	__TEST_INVARIANT;

	const TUint8* base=iBase;

	if (base)

		{

		const TUint8* end = base;

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

			{

			int bytes = TheAttributeLength[*end++];

			if (bytes == 0)

				bytes = *end++;

			end += bytes;

			}

		int length = end - base;

		aStream.WriteInt32L(length);

		aStream.WriteL(base,length);

		}

	else

		aStream.WriteInt32L(0);

	}

void RFormatStream::InternalizeL(RReadStream& aStream)

// Load the buffer from the specified stream

//

	{

	TestInvariantL();

	TInt length=aStream.ReadInt32L();

	//

	if (length<0 || length>KMaxFormatStreamLength)

		User::Leave(KErrCorrupt);

	//

	if (length==0)

		Reset();

	else

		{

		AllocL(length);

		aStream.ReadL(iBase,length);

		}

	TestInvariantL();

	}

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

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

	{

	__TEST_INVARIANT;

	aLength=iEnd-iBase;

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

	return iBase;

	}

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

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

	{

	TInt size=DoCalcSizeCharFormat(aCharFormatX,aMask);

	if (size==0)

		Reset();

	else

		{

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

		DoStoreCharFormat(aCharFormatX,aMask);

		}

	__TEST_INVARIANT;

	}

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

											const CParaFormat& aCurrentFormat)

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

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

// propagate the leave.

//

	{

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

	if (size==0)

		Reset();

	else

		{

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

		DoSetParaFormat(aDesiredFormat,aDesiredMask,aCurrentFormat);

		}

	__TEST_INVARIANT;

	}

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

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

	{

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

	if (index)

		{

		*aPtr++ = TUint8(aAttrib);

		*aPtr++ = index;

		}

	}

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

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

	{

	TUint index = *aPtr;

	aColor.SetSystemColorIndex(index); 

	}

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

void RFormatStream::DoSetParaFormat(const CParaFormat& aDesiredFormat,

									TParaFormatMask aMask,

									const CParaFormat& aCurrentFormat)

	{

	TUint8* ptr=iBase;

	if (aMask.AttribIsSet(EAttFillColor))

		{

		*ptr++=TUint8(EAttFillColor);

		ptr=Store(ptr,aDesiredFormat.iFillColor);

		}

	if (aMask.AttribIsSet(EAttLeftMargin))

		{

		*ptr++=TUint8(EAttLeftMargin);

		Write32(ptr,aDesiredFormat.iLeftMarginInTwips);

		}

	if (aMask.AttribIsSet(EAttRightMargin))

		{

		*ptr++=TUint8(EAttRightMargin);

		Write32(ptr,aDesiredFormat.iRightMarginInTwips);

		}

	if (aMask.AttribIsSet(EAttIndent))

		{

		*ptr++=TUint8(EAttIndent);

		Write32(ptr,aDesiredFormat.iIndentInTwips);

		}

	if (aMask.AttribIsSet(EAttAlignment))

		{

		*ptr++=TUint8(EAttAlignment);

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

		}

	if (aMask.AttribIsSet(EAttVerticalAlignment))

		{

		*ptr++=TUint8(EAttVerticalAlignment);

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

		}

	if (aMask.AttribIsSet(EAttLineSpacing))

		{

		*ptr++=TUint8(EAttLineSpacing);

		Write32(ptr,aDesiredFormat.iLineSpacingInTwips);

		}

	if (aMask.AttribIsSet(EAttLineSpacingControl))

		{

		*ptr++=TUint8(EAttLineSpacingControl);

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

		}

	if (aMask.AttribIsSet(EAttSpaceBefore))

		{

		*ptr++=TUint8(EAttSpaceBefore);

		Write32(ptr,aDesiredFormat.iSpaceBeforeInTwips);

		}

	if (aMask.AttribIsSet(EAttSpaceAfter))

		{

		*ptr++=TUint8(EAttSpaceAfter);

		Write32(ptr,aDesiredFormat.iSpaceAfterInTwips);

		}

	if (aMask.AttribIsSet(EAttKeepTogether))

		{

		*ptr++=TUint8(EAttKeepTogether);

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

		}

	if (aMask.AttribIsSet(EAttKeepWithNext))

		{

		*ptr++=TUint8(EAttKeepWithNext);

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

		}

	if (aMask.AttribIsSet(EAttStartNewPage))

		{

		*ptr++=TUint8(EAttStartNewPage);

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

		}

	if (aMask.AttribIsSet(EAttWidowOrphan))

		{

		*ptr++=TUint8(EAttWidowOrphan);

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

		}

	if (aMask.AttribIsSet(EAttWrap))

		{

		*ptr++=TUint8(EAttWrap);

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

		}

	if (aMask.AttribIsSet(EAttBorderMargin))

		{

		*ptr++=TUint8(EAttBorderMargin);

		Write32(ptr,aDesiredFormat.iBorderMarginInTwips);

		}

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

		{

		if (aMask.AttribIsSet(EAttTopBorder))

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

		if (aMask.AttribIsSet(EAttBottomBorder))

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

		if (aMask.AttribIsSet(EAttLeftBorder))

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

		if (aMask.AttribIsSet(EAttRightBorder))

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

		}

	if (aMask.AttribIsSet(EAttDefaultTabWidth))

		{

		*ptr++=TUint8(EAttDefaultTabWidth);

		Write32(ptr,aDesiredFormat.iDefaultTabWidthInTwips);

		}

	if (aMask.AttribIsSet(EAttTabStop))

		{

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

		StoreTabs(tptr,aDesiredFormat,aCurrentFormat,ETrue);

		ptr=tptr;

		}

	if (aMask.AttribIsSet(EAttBullet))