/*

* Copyright (c) 2006-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 "TmLayoutImp.h"

#include "frmUtils.h"

CTmFormatContext::CTmFormatContext(MTmSource& aSource,const TTmFormatParam& aFormatParam,CTmCode& aCode,

								   CTmTextLayout* aTextLayout,const TBidirectionalContext* aBdContext):

	iSource(aSource),

	iParam(aFormatParam),

	iTextCache(aSource,aSource.FormatDevice()),

	iCode(aCode),

	iLineInPar(iParam.iLineInPar),

	iTextLayout(aTextLayout)

	{

	iInfo.iEndChar = iParam.iStartChar;

	iDocumentLength = iSource.DocumentLength();

	iActualEndChar = Min(iParam.iEndChar,iDocumentLength + 1);

	if (aBdContext)

		iBdState = *aBdContext;

	CalculateScale(iSource,iXScale,iYScale);

	}

CTmFormatContext::~CTmFormatContext()

	{

	iTextCache.Close();

	iParFormat.Close();

	}

void CTmFormatContext::ResolveParagraphDirectionality()

	{

	if (!(iParFormat.iFlags & RTmParFormat::EDirectionalityFromText))

		// Paragraph directionality is explicit.

		return;

	// iInfo.iEndChar is actually the start of this line, as the line has not been

	// set up yet!

	TInt positionOfLastStrongCategoryInPara = 0;

	TInt startPosOfThisLine = -1;

	TChar::TBdCategory firstStrongCategory = FirstStrongCategoryInParagraph(

		iSource.ParagraphStart(iInfo.iEndChar), iTextCache, positionOfLastStrongCategoryInPara, startPosOfThisLine);

	// Override the directionality set in ERightToLeft only if the text

	// gives us the information.

	if (firstStrongCategory < TChar::ERightToLeft)

		{

		iParFormat.iFlags &= ~RTmParFormat::ERightToLeft;

		iParFormat.iFlags &= ~RTmParFormat::EDirectionalityFromText;

		}

	else if (firstStrongCategory <= TChar::ERightToLeftOverride)

		{

		iParFormat.iFlags |= RTmParFormat::ERightToLeft;

		iParFormat.iFlags &= ~RTmParFormat::EDirectionalityFromText;

		}

	}

void CTmFormatContext::SetParagraphMetricsL()

	{

	iSource.GetParagraphFormatL(iInfo.iEndChar,iParFormat);

	ResolveParagraphDirectionality();

	int bullet_margin, bullet_width;

	MGraphicsDeviceMap& device = Device();

	TmGetMarginsL(device,iParFormat,iLeftMargin,iRightMargin,iFirstLineLeftMargin,iFirstLineRightMargin,

				  bullet_margin,bullet_width,iBulletAscent,iBulletDescent);

	iLineSpacing = iParFormat.iLineSpacing;

	if (iLineSpacing && (!(iParFormat.iFlags & RTmParFormat::EPixelLineSpacing)))

		iLineSpacing = device.VerticalTwipsToPixels(iLineSpacing);

	iExactLineSpacing = iParFormat.iFlags & RTmParFormat::EExactLineSpacing;

	iSpaceBefore = iParFormat.iSpaceAbove;

	if (iSpaceBefore)

		iSpaceBefore = device.VerticalTwipsToPixels(iSpaceBefore);

	iSpaceAfter = iParFormat.iSpaceBelow;

	if (iSpaceAfter)

		iSpaceAfter = device.VerticalTwipsToPixels(iSpaceAfter);

	if (iParFormat.HaveBorders())

		{

		int dummy;

		iHBorderMargin = device.HorizontalTwipsToPixels(iParFormat.iBorderMargin);

		iVBorderMargin = device.VerticalTwipsToPixels(iParFormat.iBorderMargin);

		TmGetBorderWidth(device,iParFormat,RTmParFormat::ETopBorder,dummy,iTopBorder);

		TmGetBorderWidth(device,iParFormat,RTmParFormat::EBottomBorder,dummy,iBottomBorder);

		TmGetBorderWidth(device,iParFormat,RTmParFormat::ELeadingBorder,dummy,iLeftBorder);

		TmGetBorderWidth(device,iParFormat,RTmParFormat::ETrailingBorder,dummy,iRightBorder);

		}

	else

		iLeftBorder = iRightBorder = iTopBorder = iBottomBorder = iHBorderMargin = iVBorderMargin = 0;

	}

// A static function to format a range of text.

void CTmFormatContext::FormatL(MTmSource& aSource,const TTmFormatParam& aFormatParam,CTmCode& aCode,TInfo& aInfo,

	CTmTextLayout* aTextLayout, const TBidirectionalContext* aStartBdState, TBidirectionalContext* aEndBdState,

	TBidirectionalEndOfLineContext* aStartBdContext)

	{

	CTmFormatContext *context = new(ELeave) CTmFormatContext(aSource,aFormatParam,aCode,aTextLayout,aStartBdState);

	//	Set the context obtained from the previous line from the byte code, if it exists. If not, then it will be just NULL

	context->iTextLayout->SetCurrentContextChar(aInfo.iContextCharPerLine);

	CleanupStack::PushL(context);

	if (aStartBdContext)

		aStartBdContext->Set(context->iTextCache, aFormatParam.iStartChar);

	context->FormatL();

	aInfo = context->iInfo;

	if (aEndBdState)

		aEndBdState->Set(context->iBdState, context->iBdEndOfLine);

	CleanupStack::PopAndDestroy(context);

	}

void CTmFormatContext::FormatL()

	{

	// Format lines until the text is used up.

	TBool at_least_max_height = iParam.iFlags & TTmFormatParamBase::EAtLeastMaxHeight;

	TBool too_high = FALSE;

	int lines = 0;

	iInfo.iFirstLineEndChar = -1;

	int margin_width = 0;

	while (iInfo.iEndChar < iActualEndChar && lines < iParam.iMaxLines && !too_high)

		{

		if (lines == 0 || iLineInPar == 0)

			{

			SetParagraphMetricsL();

			}

		if (iLineInPar == 0)

			{

			iBdState.Reset();

			iBdEndOfLine.Reset();

			}

		margin_width = iLineInPar == 0 ? iFirstLineLeftMargin + iFirstLineRightMargin : iLeftMargin + iRightMargin;

		// Set the context for this line obtained from the previous line before formatting this line		

		iLine.SetContextChar(iTextLayout->GetCurrentContextChar(), EFalse);

		iLine.FormatL(*this);

		// Set the context of this line once it has been formatted. This context is the context of the last chunk of this line,

		// so that the next line can continue in the same context.

		iLine.SetContextChar(0, ETrue);

		// Set the context of this line to CTmTextLayout to keep a record of it.

		iTextLayout->SetCurrentContextChar(iLine.GetContextChar());

		iInfo.iLastLineStartChar = iInfo.iEndChar;

		if (iInfo.iFirstLineEndChar == -1)

			iInfo.iFirstLineEndChar = iLine.NextLineStartChar();

		int scaled_next_height = iInfo.iHeight + iLine.Height();

		if (iYScale != 1000)

			scaled_next_height = scaled_next_height * iYScale / 1000;

		too_high = scaled_next_height > iParam.iMaxHeight;

		if (too_high && !at_least_max_height)

			break;

		iLine.WriteCodeL(*this);

		int width = iLine.InnerBounds().Width() + margin_width;

		if (width > iInfo.iWidth)

			iInfo.iWidth = width;

		iInfo.iHeight += iLine.Height();

		if (iLine.AtParEnd())

			iLineInPar = 0;

		else

			iLineInPar++;

		lines++;

		iInfo.iEndChar = iLine.NextLineStartChar();

		}

	// Scale the height and width if necessary.

	if (iYScale != 1000)

		iInfo.iHeight = iInfo.iHeight * iYScale / 1000;

	if (iXScale != 1000)

		iInfo.iWidth = iInfo.iWidth * iXScale / 1000;

	}

/*

Get the margins and bullet metrics. If there is a bullet and aFont is non-null, return a font

that may be used to draw the bullet.

*/

void TmGetMarginsL(MGraphicsDeviceMap& aDevice,const RTmParFormat& aParFormat,

				   TInt& aLeftMargin,TInt& aRightMargin,

				   TInt& aFirstLineLeftMargin,TInt& aFirstLineRightMargin,

				   TInt& aBulletMargin,TInt& aBulletWidth,

				   TInt& aBulletAscent,TInt& aBulletDescent,CFont** aFont)

	{

	int trailing_margin = aParFormat.iTrailingMargin;

	if (trailing_margin)

		trailing_margin = aDevice.HorizontalTwipsToPixels(trailing_margin);

	// Bullets change the leading margin and first-line indent.

	int leading_margin = aParFormat.iLeadingMargin;

	int indent = aParFormat.iFirstLineIndent;

	const TTmBullet* bullet = aParFormat.Bullet();

	if (bullet)

		{

		TFontSpec fontspec;

		bullet->iFontSpec.GetTFontSpec(fontspec);

		CFont* font = NULL;

		TInt error = aDevice.GetNearestFontInTwips(font,fontspec);

		if (!font)

			User::Leave(error);

		aBulletWidth = font->CharWidthInPixels(bullet->iCharacterCode);

		aBulletAscent = font->AscentInPixels();

		aBulletDescent = font->DescentInPixels();

		if (aFont)

			*aFont = font;

		else

			aDevice.ReleaseFont(font);

		int first_line_indent = leading_margin + indent;

		if (bullet->iHangingIndent)

			{

			aBulletMargin = aDevice.HorizontalTwipsToPixels(Min(leading_margin,first_line_indent));

			first_line_indent = leading_margin = Max(leading_margin,first_line_indent);

			}

		else

			aBulletMargin = aDevice.HorizontalTwipsToPixels(leading_margin);

		indent = first_line_indent - leading_margin;

		}

	else

		aBulletMargin = aBulletWidth = aBulletAscent = aBulletDescent = 0;

	if (leading_margin)

		leading_margin = aDevice.HorizontalTwipsToPixels(leading_margin);

	/*

	Indents are converted to pixels like this so that if the indent in twips is

	the negative of the leading margin, so as to get a zero indent for the first line, this

	is also true after conversion to pixels. Not doing this causes twip values of 360 and -360

	to become 30 and -29 pixels at standard Series 5 resolution.

	*/

	if (indent >= 0)

		indent = aDevice.HorizontalTwipsToPixels(indent);

	else if (indent < 0)

		indent = -aDevice.HorizontalTwipsToPixels(-indent);

	int bullet_overshoot = aBulletMargin + aBulletWidth - leading_margin - indent;

	if (bullet_overshoot > 0)

		indent += bullet_overshoot;

	if (aParFormat.RightToLeft())

		{

		aLeftMargin = trailing_margin;

		aRightMargin = leading_margin;

		aFirstLineLeftMargin = trailing_margin;

		aFirstLineRightMargin = leading_margin + indent;

		}

	else

		{

		aLeftMargin = leading_margin;

		aRightMargin = trailing_margin;

		aFirstLineLeftMargin = leading_margin + indent;

		aFirstLineRightMargin = trailing_margin;

		}

	}

void TmGetBorderWidth(const MGraphicsDeviceMap& aDevice,const RTmParFormat& aParFormat,RTmParFormat::TBorderIndex aSide,

					  TInt& aSingle,TInt& aFull)

	{

	aSingle = 0;

	const TTmParBorder* b = aParFormat.Border(aSide);

	if (b)

		{

		int width = b->iWeight;

		if (width)

			{

			if (aSide == RTmParFormat::ELeadingBorder || aSide == RTmParFormat::ETrailingBorder)

				width = aDevice.HorizontalTwipsToPixels(width);

			else

				width = aDevice.VerticalTwipsToPixels(width);

			if (width <= 0)

				width = 1;

			aSingle = width;

			if (b->iStyle == TTmParBorder::EDoubleStyle)

				aFull = width * 3;

			else

				aFull = width;

			}

		}

	}

// Subtract aQ from aP, giving four non-overlapping remainder rectangles aR, any or all of which may be empty.

void SubtractRect(const TRect& aP,const TRect& aQ,TRect* aR)

	{

	TRect q = aQ;

	q.Intersection(aP);

	if (q.IsEmpty())

		q.SetRect(aP.iTl,aP.iTl);

	aR[0] = aP;

	aR[0].iBr.iY = q.iTl.iY;

	aR[1] = aP;

	aR[1].iTl.iY = q.iBr.iY;

	aR[2] = q;

	aR[2].iTl.iX = aP.iTl.iX;

	aR[2].iBr.iX = q.iTl.iX;

	aR[3] = q;

	aR[3].iTl.iX = q.iBr.iX;

	aR[3].iBr.iX = aP.iBr.iX;

	}