/*

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

#include "TmChunkInterp.h"

#include "InlineText.h"

#include "frmUtils.h"

inline TBool IsSurrogate(TText a) { return 0xD800 == (a & 0xF800); }

inline TBool IsHighSurrogate(TText a) { return 0xD800 == (a & 0xFC00); }

inline TBool IsLowSurrogate(TText a) { return 0xDC00 == (a & 0xFC00); }

inline TChar JoinSurrogates(TText aHigh, TText aLow)

	{

	return ((aHigh - 0xd7f7) << 10) + aLow;

	}

inline TText16 GetHighSurrogate(TUint aChar)

	{

	return STATIC_CAST(TText16, 0xD7C0 + (aChar >> 10));

	}

inline TText16 GetLowSurrogate(TUint aChar)

	{

	return STATIC_CAST(TText16, 0xDC00 | (aChar & 0x3FF));

	}

CTmLine::CTmLine():

	iText(128),

	iTextWithoutChunkOverlaps(128),

	iChunk(32),

	iRunInfo(32),

	iCountedEndChar(0),

	iHangingEndChar(0),

	iEndChar(0),

	iNextLineStartChar(0),	

	iAtParEnd(FALSE),

	iEllipsis(0xFFFF),

	iEllipsisFormat(0),

	iEllipsisWidth(0),

	iContextChar(NULL)

	{

	}

// Format a line using the information from a format context.

void CTmLine::FormatL(CTmFormatContext& aContext)

	{

	// Reset arrays and parameters.

	iChunk.Reset();

	iText.Reset();

	iTextWithoutChunkOverlaps.Reset();

	iRunInfo.Reset();

	iCountedEndChar = iHangingEndChar = iEndChar = iNextLineStartChar = 0;

	iAtParEnd = FALSE;

	iHeight = iAscent = 0;

	iInnerBounds.SetRect(0,0,0,0);

	iEllipsis = 0xFFFF;

	// Determine the line break.

	int start_x_coord = aContext.iLineInPar == 0 ? aContext.iFirstLineLeftMargin : aContext.iLeftMargin;

	int align_x_coord = aContext.iParam.iWrapWidth -

						(aContext.iLineInPar == 0 ? aContext.iFirstLineRightMargin : aContext.iRightMargin);

	int wrap_x_coord = KMaxTInt;

	if (aContext.iParam.IsWrapping() && !(aContext.iParFormat.iFlags & RTmParFormat::ENoWrap))

		wrap_x_coord = align_x_coord;

	BreakL(aContext,start_x_coord,wrap_x_coord);

	// Calculate the ascent, descent and width.

	TInt width;

	TInt descent;

	CalculateMetrics(aContext,width,iAscent,descent);

	// Determine if the line has any border rules.

	iBordered = aContext.iLeftBorder || aContext.iRightBorder ||

				(aContext.iTopBorder && aContext.iLineInPar == 0) ||

				(aContext.iBottomBorder && iAtParEnd);

	// Determine the next bidirectional category and next strong bidirectional category

	aContext.iBdEndOfLine.Set(aContext.iTextCache, iNextLineStartChar);

	/*

	Calculate the bounds of the line. The outer bounds of the lines in a band completely tile

	the band, and are a series of full-width horizontal slices; these are defined completely by their heights,

	so iHeight represents the outer bounds. The inner bounds surround the actual text, not including margins,

	indents and space above and below lines and paragraphs.

	*/

	iInnerBounds.SetRect(start_x_coord,0,start_x_coord + width,KMaxTInt);

	if (aContext.iLineInPar == 0)

		{

		iInnerBounds.iTl.iY += aContext.iSpaceBefore;

		if (iBordered && aContext.iTopBorder)

			iInnerBounds.iTl.iY += aContext.iVBorderMargin + aContext.iTopBorder;

		}

	iHeight = iInnerBounds.iBr.iY = iInnerBounds.iTl.iY + iAscent + descent;

	if (iAtParEnd)

		{

		iHeight += aContext.iSpaceAfter;

		if (iBordered && aContext.iBottomBorder)

			iHeight += aContext.iVBorderMargin + aContext.iBottomBorder;

		}

	// Perform right alignment, centring or full justification.

	int measure = align_x_coord - start_x_coord;

	switch (aContext.iParFormat.iAlignment)

		{

		case RTmParFormat::EAlignNormalBidirectional:

			if (aContext.iParFormat.RightToLeft())

				{

				if(measure - width < 0)

					{

					iInnerBounds.Move(0, 0);	

					}

					else

					{

					iInnerBounds.Move(measure - width, 0);		

					}

				}

			break;

		case RTmParFormat::EAlignReverseBidirectional:

			if (!aContext.iParFormat.RightToLeft())

				iInnerBounds.Move(measure - width, 0);

			break;

		case RTmParFormat::EAlignCenter:

			iInnerBounds.Move((measure - width) / 2,0);

			break;

		case RTmParFormat::EAlignJustify:

			if (iAtParEnd || measure <= width)

				{

				// Default to normal bidirectional for the last line of

				// a paragraph or if the margins are broken.

				if (aContext.iParFormat.RightToLeft())

					iInnerBounds.Move(measure - width, 0);

				}

			else

				Justify(measure - width);

			break;

		case RTmParFormat::EAlignAbsoluteLeft:

			// default is left

			break;

		case RTmParFormat::EAlignAbsoluteRight:

			iInnerBounds.Move(measure - width, 0);

			break;

		default:

			break;

		}

	}

// Find the line break.

void CTmLine::BreakL(CTmFormatContext& aContext,TInt aStartXCoord,TInt aWrapXCoord)

	{

	aContext.iLineEndsInForcedLineBreak = EFalse;

	TInt truncate_x_coord = aWrapXCoord;

	TBool truncating_with_ellipsis = aContext.iParam.IsTruncatingWithEllipsis(); // ####################

	if (truncating_with_ellipsis)

		truncate_x_coord = aContext.iParam.iWrapWidth - aContext.iRightMargin;

	// The following character positions are all relative to the document, not the line.

	TInt start_pos = aContext.iInfo.iEndChar;	// line start

	TInt truncate_pos_with_ellipsis = KMaxTInt;	// position of truncation, allowing room for an ellipsis

	TInt truncate_pos = KMaxTInt;				// position of truncation

	TInt wrap_pos = KMaxTInt;					// position at the full measure

	TInt break_pos = KMaxTInt;					// legal break position

	CTmLine::TEllipsisInfo ellipsisInfo;		// structure used to carry info back from AppendChunk(s)L

	// Fill the line up to the truncation width.

	TInt cur_pos = start_pos;

	TInt cur_x_coord = aStartXCoord;

	TInt maxChar = aContext.iDocumentLength + 1;

	AppendChunksL(aContext, cur_pos, cur_x_coord, maxChar, truncate_x_coord, truncating_with_ellipsis, ellipsisInfo);

	iEllipsisFormat = ellipsisInfo.iEllipsisFormat;

	iEllipsisWidth = ellipsisInfo.iEllipsisWidth;

	truncate_pos_with_ellipsis = cur_pos;

	if (truncating_with_ellipsis)

		{

		AppendChunksL(aContext, cur_pos, cur_x_coord, maxChar, truncate_x_coord, EFalse, ellipsisInfo);

		}

	truncate_pos = cur_pos;

	// Fill the line up to the wrap width if it is greater than the truncation width.

	if (aWrapXCoord > truncate_x_coord)

		{

		AppendChunksL(aContext, cur_pos, cur_x_coord, maxChar, aWrapXCoord, EFalse, ellipsisInfo);

		}

	wrap_pos = cur_pos;

	// If the line has not been ended by a paragraph break or forced line end find a possible break.

	TBool line_break_found = FALSE;

	if (ellipsisInfo.iAtLineEnd || ellipsisInfo.iAtParEnd)

		{

		break_pos = wrap_pos;

		line_break_found = TRUE;

		aContext.iLineEndsInForcedLineBreak = ETrue;

		}

	TBool get_line_break_forwards = FALSE;

	TInt min_break_pos = start_pos + 1;

	TInt hanging_break_pos = break_pos;

	TInt break_pos_after_spaces = break_pos;

	while (!line_break_found)

		{

		TInt max_break_pos = cur_pos;

		TInt context_end_pos = Min(aContext.iDocumentLength + 1,

			max_break_pos + MTmSource::ELineBreakContext);

		// Check if context_end_pos points to surrogate high part

		// If it is, the line break cannot correct, then adjust context_end_pos

		if ( cur_pos <= aContext.iDocumentLength )

		    {

            TTmCharFormat new_format;

            TPtrC text;

            aContext.iSource.GetText( cur_pos, text, new_format );

            if ( context_end_pos > cur_pos && text.Length() > 1 &&

                    IsHighSurrogate( text[ text.Length() - 1 ] ) )

                {

                --context_end_pos;

                }

		    }

		// Append line breaking context.

		AppendChunksL(aContext, cur_pos, cur_x_coord, context_end_pos, KMaxTInt, EFalse, ellipsisInfo);

		TInt chars_appended = cur_pos - max_break_pos;

		TPtrC p(iTextWithoutChunkOverlaps.Ptr(),iTextWithoutChunkOverlaps.Length());

		if (aContext.iSource.GetLineBreakL(p,start_pos,min_break_pos - start_pos,max_break_pos - start_pos,

										   get_line_break_forwards,break_pos,hanging_break_pos,break_pos_after_spaces))	

			{

			if (hanging_break_pos > iTextWithoutChunkOverlaps.Length() || break_pos_after_spaces > iTextWithoutChunkOverlaps.Length())

				TmPanic(EBadLineBreak);

			break_pos += start_pos;

			hanging_break_pos += start_pos;

			break_pos_after_spaces += start_pos;

			if (break_pos < min_break_pos || break_pos > max_break_pos)

				TmPanic(EBadLineBreak);

			if (hanging_break_pos < break_pos || break_pos_after_spaces < hanging_break_pos)

				TmPanic(EBadLineBreak);

			line_break_found = TRUE;

			}

		// If no break has been found and no more characters could be added, break here.

		else if (chars_appended == 0)

			{

			break_pos = hanging_break_pos = break_pos_after_spaces = max_break_pos;

			line_break_found = TRUE;

			}

		/*

		If no line break has been found, and if we prefer to break at an illegal position rather

		than exceeding the measure, break at the truncation position but make sure the line

		contains at least one character.

		*/

		if (!line_break_found && !aContext.iParam.LegalLineBreaksOnly())

			{

			break_pos = hanging_break_pos = break_pos_after_spaces = Max(wrap_pos,min_break_pos);

			line_break_found = TRUE;

			}

		/*

		After the first iteration, switch to searching forwards for a line break, because we know that the

		text is now too wide and we want the shortest possible overlength line.

		*/

		get_line_break_forwards = TRUE;

		min_break_pos = max_break_pos;

		}

	if (truncating_with_ellipsis && break_pos > truncate_pos)

		{

		iCountedEndChar = iHangingEndChar = iEndChar = truncate_pos_with_ellipsis;

		iEllipsis = aContext.iParam.iEllipsis;

		}

	else

		{

		iCountedEndChar = break_pos;

		iHangingEndChar = hanging_break_pos;

		iEndChar = break_pos_after_spaces;

		}

	// Determine whether the line ends at the end of the paragraph.

	iAtParEnd = break_pos_after_spaces == ellipsisInfo.iParEndPos;

	if (iAtParEnd)

		aContext.iLineEndsInForcedLineBreak = ETrue;

	iNextLineStartChar = break_pos_after_spaces;

	/*

	Truncate the text after the displayed characters, ensuring there is a break of chunk at this point.

	This makes it easier to justify the line and write the bytecode.

	*/

	if (iCountedEndChar < cur_pos)

		{

		int chunk_start_pos = start_pos;

		int chunk_end_pos = start_pos;

		int chunk_index = 0;

		cur_x_coord = aStartXCoord;

		// find the chunk that contains the end of the text,(iCountedEndChar)

		while (chunk_index < iChunk.Length())

			{

			chunk_end_pos += (iChunk[chunk_index].iTextLength - iChunk[chunk_index].iOverlappingChars);

			if (chunk_end_pos > iCountedEndChar)

				break;

			cur_x_coord += iChunk[chunk_index].iWidth;

			chunk_start_pos = chunk_end_pos;

			chunk_index++;

			}

		//  remove the chunk that contains the last bit of text and any after

		iChunk.Truncate(chunk_index);

		iRunInfo.Truncate(chunk_index);

		iText.Truncate(chunk_start_pos - start_pos);

		cur_pos = chunk_start_pos;

		// add a chunks so there is just enough text to reach the end

		while (cur_pos < iCountedEndChar)

			{

			if (!AppendChunkL(aContext,cur_pos,cur_x_coord,iCountedEndChar,KMaxTInt,FALSE,ellipsisInfo))

				break;

			}

		while (cur_pos < iHangingEndChar)

			{

			if (!AppendChunkL(aContext,cur_pos,cur_x_coord,iHangingEndChar,KMaxTInt,FALSE,ellipsisInfo))

				break;

			}

		// If the last chunk is a soft hyphen restore its full width.		

		if (iChunk.Length())

			{

			TTmChunk& last_chunk = iChunk[iChunk.Length() - 1];

			if (last_chunk.iType == TTmChunk::ESoftHyphenChunk)

				last_chunk.iWidth = last_chunk.iStandardWidth;

			}

		}

	}

// Determine the ascent, descent and width of a line.

void CTmLine::CalculateMetrics(CTmFormatContext& aContext,TInt& aWidth,TInt& aAscent,TInt& aDescent) const

	{

	aWidth = 0;

	aAscent = 0;

	aDescent = 0;

	MTmSource::TLineHeightParam p;

	p.iFontMaxAscent = aContext.iBulletAscent;

	p.iFontMaxDescent = aContext.iBulletDescent;

	int i = 0;

	const TTmChunk* c = NULL;

	for (i = 0, c = iChunk.Ptr(); i < iChunk.Length(); i++, c++)

		{

		if (c->iType == TTmChunk::EPictureChunk)

			{

			switch (c->iFormat.iPictureAlignment)

				{

				case TTmCharFormat::EPictureAlignTop:

					if (c->iMaxCharHeight > p.iMaxTopPictureHeight)

						p.iMaxTopPictureHeight = c->iMaxCharHeight;

					break;

				case TTmCharFormat::EPictureAlignBottom:

					if (c->iMaxCharHeight > p.iMaxBottomPictureHeight)

						p.iMaxBottomPictureHeight = c->iMaxCharHeight;

					break;

				case TTmCharFormat::EPictureAlignCenter:

					if (c->iMaxCharHeight > p.iMaxCenterPictureHeight)

						p.iMaxCenterPictureHeight = c->iMaxCharHeight;

					break;

				case TTmCharFormat::EPictureAlignBaseline:

					if (c->iMaxCharHeight > p.iMaxCharHeight)

						p.iMaxCharHeight = c->iMaxCharHeight;

					break;

				}

			}

		else

			{

			// Need to include the baseline offset in the Ascent/Decent 

			// calculations in case the font for this chunk is a 

			// superscript/subscript font. Offset will be 0 for a normal font.

			// Greatest Ascent = iAscent+ABS(iBaselineOffset)

			// Greatest Descent = MAX(p.iFontMaxDescent, c->iBaselineOffset)

			// See defect INC000926.

			if ((c->iAscent-c->iBaselineOffset) > p.iFontMaxAscent)

				p.iFontMaxAscent = c->iAscent - c->iBaselineOffset;

			if ((c->iDescent > p.iFontMaxDescent) || (c->iBaselineOffset > p.iFontMaxDescent))

				p.iFontMaxDescent = Max(c->iDescent, c->iBaselineOffset);

			if (c->iMaxCharHeight > p.iMaxCharHeight)

				p.iMaxCharHeight = c->iMaxCharHeight;

			if (c->iMaxCharDepth > p.iMaxCharDepth)

				p.iMaxCharDepth = c->iMaxCharDepth;

			if (c->iFontMaxHeight > p.iFontMaxCharHeight)

				p.iFontMaxCharHeight = c->iFontMaxHeight;

			if (c->iFontMaxDepth > p.iFontMaxCharDepth)

				p.iFontMaxCharDepth = c->iFontMaxDepth;

			}

		aWidth += c->iWidth;

		}

	if (iEllipsis != 0xFFFF)

		aWidth += iEllipsisWidth;

	// If the line has no characters set the ascent and descent to those of the current font.

	if (!iChunk.Length() || !(p.iFontMaxAscent || p.iFontMaxDescent))

		{

		TPtrC text;

		CTmTextFontCache* font = NULL;

		aContext.iTextCache.GetText(aContext.iInfo.iEndChar,KMaxTInt,text,NULL,&font);

		if (font)

			{

			// Changes for defects INC000922 & DEF000925. 

			// If a bullet point is present at the start of an empty paragraph

			// which is bigger than the text font size then we need to preserve

			// the bullet point sizes set above over the font sizes. This is

			// why IFs surround the two assignments below. 

			if (font->Font().AscentInPixels() > p.iFontMaxAscent)

				p.iFontMaxAscent = font->Font().AscentInPixels();

			if (font->Font().DescentInPixels() > p.iFontMaxDescent)

				p.iFontMaxDescent = font->Font().DescentInPixels();

			/* get the MaxCharHeight and MaxCharDepth */

			GetMaxHeightAndDepth(&font->Font(), p.iFontMaxCharHeight, p.iFontMaxCharDepth ); 

			font->Close();

			}

		}

	// Set the line's ascent and descent to take account of desired minimum line height, overlarge characters, etc.

	p.iDesiredLineHeight = aContext.iLineSpacing;

	p.iExactLineHeight = aContext.iExactLineSpacing;

	aContext.iSource.SetLineHeight(p,aAscent,aDescent);

	}

void CTmLine::Justify(TInt aExtraSpace)

	{

	/*

	Find the range to stretch: from the chunk after the last tab to the penultimate chunk;

	but don't stretch if the last tab was not a standard tab.

	*/

	int last = iChunk.Length() - 1;

	int first = last;

	int i;

	TBool non_standard_tab = FALSE;

	for (i = last - 1; i >= 0; i--)

		{

		if (iChunk[i].iType & TTmChunk::ETabFlag)

			{

			if (iChunk[i].iType != TTmChunk::EStandardTabChunk)

				non_standard_tab = TRUE;

			break;

			}

		first = i;

		}

	if (first >= last || non_standard_tab)

		return;

	// Total the stretchability.

	int stretch = 0;

	TTmChunk* c;

	for (i = first, c = iChunk.Ptr() + first; i < last; i++, c++)

		stretch += c->iStretch;

	// Do nothing if there's no stretchability.

	if (stretch == 0)

		return;

	// Adjust the line bounds.

	iInnerBounds.iBr.iX += aExtraSpace;

	// Add space to the stretchable chunks in proportion to their stretchability.

	while (aExtraSpace > 0)

		{

		int dividend = aExtraSpace;

		for (i = first, c = iChunk.Ptr() + first; i < last && aExtraSpace > 0; i++, c++)

			if (c->iStretch > 0)

				{

				c->iType = TTmChunk::EStretchedChunk;

				int increment = (dividend * c->iStretch) / stretch;

				if (increment == 0)

					increment = 1;

				if (increment > aExtraSpace)

					increment = aExtraSpace;

				c->iWidth += increment;

				aExtraSpace -= increment;

				}

		}

	}

void CTmLine::AppendChunksL(CTmFormatContext& aContext,TInt& aStartChar,TInt& aStartXPos,TInt aMaxChar,TInt aMaxXPos,

						      TBool aAllowSpaceForFinalInlineText,CTmLine::TEllipsisInfo& aEllipsisInfo)

	{

	while (aStartChar < aMaxChar && !aEllipsisInfo.iAtLineEnd && !aEllipsisInfo.iAtParEnd)

		{

		aEllipsisInfo.iEllipsisFormat = aStartChar;

		if (!AppendChunkL(aContext, aStartChar, aStartXPos, aMaxChar, aMaxXPos, aAllowSpaceForFinalInlineText, aEllipsisInfo))

			break;

		}

	if (aEllipsisInfo.iAtParEnd)

		aEllipsisInfo.iParEndPos = aStartChar;

	}

TBool CTmLine::AppendChunkL(CTmFormatContext& aContext,TInt& aStartChar,TInt& aStartXPos,TInt aMaxChar,TInt aMaxXPos,

						    TBool aAllowSpaceForFinalInlineText,CTmLine::TEllipsisInfo& aEllipsisInfo)

	{

	/*

	Find any previous non-standard tab, so that we can adjust the measure to allow for characters pushed left.

	Accumulate the segment width (width of chunks between tabs), which will be used to

	adjust the width of the previous tab if necessary.

	Return TRUE if it was possible to append a new chunk of non-zero length. It will be impossible if

	aMaxChar is <= aStartChar or the chunk consists of a ligation that ends after aMaxChar, or the smallest thing

	that can be appended is wider than aMaxXPos - aStartXPos.

	*/

	int segment_width = 0;

	TTmChunk* prev_tab = NULL;

	if (iChunk.Length() > 0)

		{

		int i = iChunk.Length() - 1;

		TTmChunk* c = &iChunk[i];