/*

* 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 <gdi.h>

#include "TXTFRMAT.H"

#include "TXTSTD.H"

const TInt KParaDefaultLanguage=0;

const TInt KParaDefaultLeftMargin=0;

const TInt KParaDefaultRightMargin=0;

const TInt KParaDefaultIndent=0;

const CParaFormat::TAlignment KParaDefaultHorizAlign=CParaFormat::ELeftAlign;

const CParaFormat::TAlignment KParaDefaultVertAlign=CParaFormat::EUnspecifiedAlign;

const TInt KParaDefaultLineSpacing=200; // 200 twips = 10pt

const CParaFormat::TLineSpacingControl KParaDefaultLineSpacingControl=CParaFormat::ELineSpacingAtLeastInTwips;

const TInt KParaDefaultSpaceBefore=0;

const TInt KParaDefaultSpaceAfter=0;

const TBool KParaDefaultKeepTogether=EFalse;

const TBool KParaDefaultKeepWithNext=EFalse;

const TBool KParaDefaultStartNewPage=EFalse;

const TBool KParaDefaultWidowOrphan=EFalse;

const TBool KParaDefaultWrap=ETrue;

const TInt KParaDefaultBorderMargin=0;

const TInt KParaDefaultTabWidth=360; // 360 twips = 0.25"

const TUint KParFormatBits = (2 << EAttTabStop) - 1;

const TUint KCharFormatBits = (2 << (EAttFontHiddenText - EAttCharLanguage)) - 1;

EXPORT_C TTabStop::TTabStop():

	iTwipsPosition(0),

	iType(ELeftTab)

/** The default C++ constructor constructs a TTabStop. The twips position is 

initialised to zero and the alignment to ELeftTab. */

 	{

	}

EXPORT_C TTabStop::TTabStop(const TTabStop& aTabStop):

	iTwipsPosition(aTabStop.iTwipsPosition),

	iType(aTabStop.iType)

	{

	}

EXPORT_C TTabStop& TTabStop::operator=(const TTabStop& aTabStop)

/** Assigns the twips position and alignment of aTabStop to the current TTabStop.

@param aTabStop The tab stop to assign to the current tab stop. 

@return The current tab stop. */

	{

	iTwipsPosition=aTabStop.iTwipsPosition;

	iType=aTabStop.iType;

	return *this;

	}

EXPORT_C TBool TTabStop::operator==(const TTabStop& aTabStop)const

/** Compares two tab stops for equality. To be equal, they must have the same 

twips position and alignment.

@param aTabStop The tab stop to compare with the current tab stop. 

@return ETrue if both tab stops have the same twips position and alignment. 

EFalse if not. */

	{

	if (iTwipsPosition!=aTabStop.iTwipsPosition)

		return EFalse;

	if (iType!=aTabStop.iType)

		return EFalse;

	return ETrue;

	}

EXPORT_C TParaBorder::TParaBorder():

	iLineStyle(ENullLineStyle),

	iThickness(0),

	iColor(TLogicalRgb::ESystemForegroundColor),

	iAutoColor(ETrue)

/** The default C++ constructor constructs a TParaBorder, initializing its line 

style to ENullLineStyle, its line thickness to zero, its colour to KRgbBlack 

and iAutocolor to ETrue. */

	{

	}

EXPORT_C TBool TParaBorder::operator==(const TParaBorder& aParaBorder)const

/** Compares two paragraph border sides for equality. For two paragraph border 

sides to be equal, all data members must be equal.

@param aBorder The paragraph border to compare with the current border.

@return ETrue if the two paragraph border sides are equal, EFalse if not. */

	{

	if (iLineStyle!=aParaBorder.iLineStyle)

		return EFalse;

	if (iThickness!=aParaBorder.iThickness)

		return EFalse;

	if (iColor!=aParaBorder.iColor)

		return EFalse;

	if (iAutoColor!=aParaBorder.iAutoColor)

		return EFalse;

	return ETrue;

	}

EXPORT_C TBullet::TBullet():

	iCharacterCode(0x2022),

	iHeightInTwips(0),

	iHangingIndent(TRUE),

	iColor(TLogicalRgb::ESystemForegroundColor),

	iStyle(EBulletStyle),

	iStartNumber(1),

	iAlignment(ELeftAlign)

/** The default C++ constructor constructs a TBullet, initializing the 

character code to 0x2022, the height to zero, the colour to the system's 

default foreground colour and the hanging indent to ETrue. The typeface 

is not initialised. */

	{

	}

EXPORT_C TBool TBullet::operator==(const TBullet& aBullet)const

/** Compares two bullet points for equality. For two bullet points to be equal, 

all data members must be equal.

@param aBullet The bullet point to compare. 

@return ETrue if the two bullet points are equal, EFalse if not. */

	{

	return iCharacterCode == aBullet.iCharacterCode &&

		   iHeightInTwips == aBullet.iHeightInTwips &&

		   iHangingIndent == aBullet.iHangingIndent &&

		   iColor == aBullet.iColor &&

		   iStyle == aBullet.iStyle &&

		   iStartNumber == aBullet.iStartNumber &&

		   iAlignment == aBullet.iAlignment &&

		   iTypeface == aBullet.iTypeface;

	}

EXPORT_C CParaFormat* CParaFormat::NewL()

/** Allocates and constructs a CParaFormat object. All attributes are 

initialised with default values.

@return The new CParaFormat object. */

	{

	return new(ELeave) CParaFormat;

	}

EXPORT_C CParaFormat* CParaFormat::NewLC()

/** Allocates and constructs a CParaFormat object. All attributes are 

initialised with default values. Leaves the object on the cleanup stack.

@return The new CParaFormat object. */

	{

	CParaFormat* self=new(ELeave) CParaFormat;

	CleanupStack::PushL(self);

	return self;

	}

EXPORT_C CParaFormat* CParaFormat::NewL(const CParaFormat& aFormat)

/** Allocates and constructs a new CParaFormat. All attributes are initialised 

to the values contained in the aFormat argument.

@param aFormat Paragraph format container whose values are used to initialise 

the new CParaFormat. 

@return The new CParaFormat object. */

	{

	CParaFormat* self = new(ELeave) CParaFormat(aFormat);

	CleanupStack::PushL(self);

	self->CopyL(aFormat);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CParaFormat::CParaFormat():

	iTabList(NULL),

	iParaBorderArray(NULL),

	iFillColor(TLogicalRgb::ESystemBackgroundColor),

	iLanguage(KParaDefaultLanguage),

	iLeftMarginInTwips(KParaDefaultLeftMargin),

	iRightMarginInTwips(KParaDefaultRightMargin),

	iIndentInTwips(KParaDefaultIndent),

	iHorizontalAlignment(KParaDefaultHorizAlign),

	iVerticalAlignment(KParaDefaultVertAlign),

	iLineSpacingInTwips(KParaDefaultLineSpacing),

	iLineSpacingControl(KParaDefaultLineSpacingControl),

	iSpaceBeforeInTwips(KParaDefaultSpaceBefore),

	iSpaceAfterInTwips(KParaDefaultSpaceAfter),

	iKeepTogether(KParaDefaultKeepTogether),

	iKeepWithNext(KParaDefaultKeepWithNext),

	iStartNewPage(KParaDefaultStartNewPage),

	iWidowOrphan(KParaDefaultWidowOrphan),

	iWrap(KParaDefaultWrap),

	iBorderMarginInTwips(KParaDefaultBorderMargin),

	iBullet(NULL),

	iDefaultTabWidthInTwips(KParaDefaultTabWidth)

/** The default C++ constructor constructs a new CParaFormat initialising all 

attributes to the default settings.

Note: This function allows a CParaFormat object to be created on the stack. This 

should only be done if it is known in advance that the object will not be 

used to store tab stops, bullets or borders. */

	{

	}

CParaFormat::CParaFormat(const CParaFormat& aFormat):

	iFillColor(aFormat.iFillColor),

	iLanguage(aFormat.iLanguage),

	iLeftMarginInTwips(aFormat.iLeftMarginInTwips),

	iRightMarginInTwips(aFormat.iRightMarginInTwips),

	iIndentInTwips(aFormat.iIndentInTwips),

	iHorizontalAlignment(aFormat.iHorizontalAlignment),

	iVerticalAlignment(aFormat.iVerticalAlignment),

	iLineSpacingInTwips(aFormat.iLineSpacingInTwips),

	iLineSpacingControl(aFormat.iLineSpacingControl),

	iSpaceBeforeInTwips(aFormat.iSpaceBeforeInTwips),

	iSpaceAfterInTwips(aFormat.iSpaceAfterInTwips),

	iKeepTogether(aFormat.iKeepTogether),

	iKeepWithNext(aFormat.iKeepWithNext),

	iStartNewPage(aFormat.iStartNewPage),

	iWidowOrphan(aFormat.iWidowOrphan),

	iWrap(aFormat.iWrap),

	iBorderMarginInTwips(aFormat.iBorderMarginInTwips),

	iDefaultTabWidthInTwips(aFormat.iDefaultTabWidthInTwips)

	{

	}

void CParaFormat::CreateTabListL()

	{

	if (!iTabList)

		iTabList = new(ELeave) CArrayFixFlat<TTabStop>(ETabStoreGranularity);

	}

EXPORT_C CParaFormat::~CParaFormat()

/** The destructor frees all resources owned by the paragraph format container 

(tabs, borders and bullets), prior to its destruction. 

Note that Strip() also sets the resource pointers to NULL. This is important 

in case CParaFormat is on the stack and gets deleted twice: once by the cleanup 

stack and once by exceptions being unwound. */

	{

	Strip();

	}

EXPORT_C void CParaFormat::CopyL(const CParaFormat& aFormat)

/** Copies all attribute values from another paragraph format container.

@param aFormat Contains the attribute values to copy. */

	{

	TParaFormatMask mask;

	mask.SetAll();

	CopyL(aFormat,mask);

	}

EXPORT_C void CParaFormat::CopyL(const CParaFormat& aFormat,const TParaFormatMask& aMask)

/** Copies selected attribute values from another paragraph format container. 

Only the attributes which are set in the mask are copied.

@param aFormat Contains the attribute values to copy. 

@param aMask Bitmask specifying the attributes to copy. */

	{

	if (aMask.AttribIsSet(EAttParaLanguage))

		iLanguage=aFormat.iLanguage;

	if (aMask.AttribIsSet(EAttFillColor))

		iFillColor=aFormat.iFillColor;

	if (aMask.AttribIsSet(EAttLeftMargin))

		iLeftMarginInTwips=aFormat.iLeftMarginInTwips;

	if (aMask.AttribIsSet(EAttRightMargin))

		iRightMarginInTwips=aFormat.iRightMarginInTwips;

	if (aMask.AttribIsSet(EAttIndent))

		iIndentInTwips=aFormat.iIndentInTwips;

	if (aMask.AttribIsSet(EAttAlignment))

		iHorizontalAlignment=aFormat.iHorizontalAlignment;

	if (aMask.AttribIsSet(EAttVerticalAlignment))

		iVerticalAlignment=aFormat.iVerticalAlignment;

	if (aMask.AttribIsSet(EAttLineSpacing))

		iLineSpacingInTwips=aFormat.iLineSpacingInTwips;

	if (aMask.AttribIsSet(EAttLineSpacingControl))

		iLineSpacingControl=aFormat.iLineSpacingControl;

	if (aMask.AttribIsSet(EAttSpaceBefore))

		iSpaceBeforeInTwips=aFormat.iSpaceBeforeInTwips;

	if (aMask.AttribIsSet(EAttSpaceAfter))

		iSpaceAfterInTwips=aFormat.iSpaceAfterInTwips;

	if (aMask.AttribIsSet(EAttKeepTogether))

		iKeepTogether=aFormat.iKeepTogether;

	if (aMask.AttribIsSet(EAttKeepWithNext))

		iKeepWithNext=aFormat.iKeepWithNext;

	if (aMask.AttribIsSet(EAttStartNewPage))

		iStartNewPage=aFormat.iStartNewPage;

	if (aMask.AttribIsSet(EAttWidowOrphan))

		iWidowOrphan=aFormat.iWidowOrphan;

	if (aMask.AttribIsSet(EAttWrap))

		iWrap=aFormat.iWrap;

	// Copy borders; create a border array only if necessary.

	if (iParaBorderArray || aFormat.iParaBorderArray)

		{

		if (!iParaBorderArray)

			iParaBorderArray = new(ELeave) TParaBorderArray;

		if (aMask.AttribIsSet(EAttTopBorder))

			iParaBorderArray->iBorder[EParaBorderTop] = aFormat.ParaBorder(EParaBorderTop);

		if (aMask.AttribIsSet(EAttBottomBorder))

			iParaBorderArray->iBorder[EParaBorderBottom] = aFormat.ParaBorder(EParaBorderBottom);

		if (aMask.AttribIsSet(EAttLeftBorder))

			iParaBorderArray->iBorder[EParaBorderLeft] = aFormat.ParaBorder(EParaBorderLeft);

		if (aMask.AttribIsSet(EAttRightBorder))

			iParaBorderArray->iBorder[EParaBorderRight] = aFormat.ParaBorder(EParaBorderRight);

		TParaBorder default_border;

		TBool borders_are_default = TRUE;

		for (int i = 0; i < 4; i++)

			if (iParaBorderArray->iBorder[i] != default_border)

				{

				borders_are_default = FALSE;

				break;

				}

		if (borders_are_default)

			RemoveAllBorders();

		}

	if (iBullet || aFormat.iBullet)

		{

		if (aMask.AttribIsSet(EAttBullet))

			{

			if (aFormat.iBullet && aFormat.iBullet->iStyle != TBullet::ENullStyle)

				{

				if (!iBullet)

					iBullet = new(ELeave) TBullet;

				*iBullet = *aFormat.iBullet;

				}

			else

				{

				delete iBullet;

				iBullet = NULL;

				}

			}

		}

	if (aMask.AttribIsSet(EAttDefaultTabWidth))

		iDefaultTabWidthInTwips = aFormat.iDefaultTabWidthInTwips;

	if (iTabList || aFormat.iTabList)

		{

		if (aMask.AttribIsSet(EAttTabStop))

			{

			RemoveAllTabs();

			if (aFormat.iTabList && aFormat.iTabList->Count())

				{

				CreateTabListL();

				iTabList->InsertL(0,&(aFormat.iTabList->At(0)),aFormat.iTabList->Count());

				}

			}

		}

	}

EXPORT_C TBool CParaFormat::IsEqual(const CParaFormat& aFormat,const TParaFormatMask& aMask) const

/** Compares selected attribute values for equality. Only the attributes 

specified in the mask are involved in the comparison.

@param aFormat Contains the attribute values to compare. 

@param aMask Bitmask specifying the attributes to compare. 

@return ETrue if the two format containers have the same values for the

attributes specified in the mask, EFalse if not. */

	{

	if (aMask.AttribIsSet(EAttParaLanguage))

		{

		if (iLanguage!=aFormat.iLanguage)

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttFillColor))

		{

		if (iFillColor!=aFormat.iFillColor)

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttLeftMargin))

		{

		if (iLeftMarginInTwips!=aFormat.iLeftMarginInTwips)

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttRightMargin))

		{

		if (iRightMarginInTwips!=aFormat.iRightMarginInTwips)

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttIndent))

		{

		if (iIndentInTwips!=aFormat.iIndentInTwips)	

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttAlignment))

		{

		if (iHorizontalAlignment!=aFormat.iHorizontalAlignment)

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttVerticalAlignment))

		{

		if (iVerticalAlignment!=aFormat.iVerticalAlignment)

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttLineSpacing))

		{

		if (iLineSpacingInTwips!=aFormat.iLineSpacingInTwips)

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttLineSpacingControl))

		{

		if (iLineSpacingControl!=aFormat.iLineSpacingControl)

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttSpaceBefore))

		{

		if (iSpaceBeforeInTwips!=aFormat.iSpaceBeforeInTwips)

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttSpaceAfter))

		{

		if (iSpaceAfterInTwips!=aFormat.iSpaceAfterInTwips)

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttKeepTogether))

		{

		if (iKeepTogether!=aFormat.iKeepTogether)

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttKeepWithNext))

		{

		if (iKeepWithNext!=aFormat.iKeepWithNext)

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttStartNewPage))

		{

		if (iStartNewPage!=aFormat.iStartNewPage)

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttWidowOrphan))

		{

		if (iWidowOrphan!=aFormat.iWidowOrphan)

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttWrap))

		{

		if (iWrap!=aFormat.iWrap)

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttBorderMargin))

		{

		if (iBorderMarginInTwips!=aFormat.iBorderMarginInTwips)

			return EFalse;

		}

	if (aMask.AttribIsSet(EAttTopBorder))

		{

		if (iParaBorderArray)

			{

			if (ParaBorder(EParaBorderTop)!=aFormat.ParaBorder(EParaBorderTop))

				return EFalse;

			}

		else

			{

			if (aFormat.ParaBorder(EParaBorderTop).iLineStyle!=TParaBorder::ENullLineStyle)

				return EFalse;

			}

		}

	if (aMask.AttribIsSet(EAttBottomBorder))

		{

		if (iParaBorderArray)

			{

			if (ParaBorder(EParaBorderBottom)!=aFormat.ParaBorder(EParaBorderBottom))

				return EFalse;

			}

		else

			{

			if (aFormat.ParaBorder(EParaBorderBottom).iLineStyle!=TParaBorder::ENullLineStyle)

				return EFalse;

			}

		}

	if (aMask.AttribIsSet(EAttLeftBorder))

		{

		if (iParaBorderArray)

			{

			if (ParaBorder(EParaBorderLeft)!=aFormat.ParaBorder(EParaBorderLeft))

				return EFalse;

			}

		else

			{

			if (aFormat.ParaBorder(EParaBorderLeft).iLineStyle!=TParaBorder::ENullLineStyle)

				return EFalse;

			}

		}

	if (aMask.AttribIsSet(EAttRightBorder))

		{

		if (iParaBorderArray)

			{

			if (ParaBorder(EParaBorderRight)!=aFormat.ParaBorder(EParaBorderRight))

				return EFalse;

			}

		else

			{

			if (aFormat.ParaBorder(EParaBorderRight).iLineStyle!=TParaBorder::ENullLineStyle)

				return EFalse;

			}

		}

	if (aMask.AttribIsSet(EAttBullet))

		{

		if (iBullet)

			{

			if (!aFormat.iBullet)

				return EFalse;

			if (*iBullet!=*aFormat.iBullet)

				return EFalse;

			}

		else

			{

			if (aFormat.iBullet)