/*

* Copyright (c) 1999-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: 

* The CTmTextLayout class: TAGMA's simplest text class. It holds the layout of rectangular piece of text.

*

*/

#include "TmLayoutImp.h"

#include "TmHighlightSource.h"

#include "TMINTERP.H"

#include "TmChunkInterp.h"

#include <txtfrmat.h>

#include "TmTextDrawExt.h"

#include <frmtlay.h>

#include "tmreformat.h"

#include "frmUtils.h"

#define UNUSED_VAR(a) a = a

/**

Construct a TTmFormatParamBase object. Set iWrapWidth, iMaxHeight and iMaxLines to 'infinity' (KMaxTInt),

iFlags to 0 (wrapping off, no truncation with ellipsis, etc.), and iEllipsis to the ordinary ellipsis character, U+2026.

*/

EXPORT_C TTmFormatParamBase::TTmFormatParamBase():

	iWrapWidth(KMaxTInt),

	iMaxHeight(KMaxTInt),

	iMaxLines(KMaxTInt),

	iFlags(0),

	iEllipsis(0x2026)

	{

	}

/**

Construct a TTmFormatParam object, setting iStartChar to 0, iEndChar to 'infinity' (KMaxTInt) and iLineInPar to 0.

*/

EXPORT_C TTmFormatParam::TTmFormatParam():

	iStartChar(0),

	iEndChar(KMaxTInt),

	iLineInPar(0)

	{

	}

/**

Construct a TTmFormatParam object with its base class part (TTmFormatParamBase) set to aBase, and setting iStartChar to 0,

iEndChar to 'infinity' (KMaxTInt) and iLineInPar to 0.

*/

EXPORT_C TTmFormatParam::TTmFormatParam(const TTmFormatParamBase& aBase):

	TTmFormatParamBase(aBase),

	iStartChar(0),

	iEndChar(KMaxTInt),

	iLineInPar(0)

	{

	}

/**

Construct a TTmReformatParam object, setting everything to 0 or FALSE apart from iMaxExtraLines, which is

set to 'infinity' (KMaxTInt).

*/

EXPORT_C TTmReformatParam::TTmReformatParam():

	iStartChar(0), 

	iOldLength(0),

	iNewLength(0),

	iMaxExtraLines(KMaxTInt),

	iParFormatChanged(FALSE),

	iParInvalid(FALSE)

	{

	}

/**

Construct a TTmReformatResult object, setting iHeightChange to 0 and iUnchangedTop and iUnformattedStart to

'infinity' (KMaxTInt).

*/

EXPORT_C TTmReformatResult::TTmReformatResult():

	iHeightChange(0),

	iUnchangedTop(KMaxTInt),

	iUnformattedStart(KMaxTInt)

	{

	}

/**

Construct an empty object with no text and zero width and height.

It is legal to call all CTmTextLayout functions on an empty object,

with the exception of AddParL and FormatL, which panic with ENoSource.

*/

EXPORT_C CTmTextLayout::CTmTextLayout() :

	iCurrentContextChar(NULL)

	{

	// do nothing

	}

/**

The destructor.

*/

EXPORT_C CTmTextLayout::~CTmTextLayout()

	{

	delete iBdStateAtEnd;

	}

/**

Set the text, discarding any existing layout information. The text from aParam.iStartChar to aParam.iEndChar is

extracted from aSource and formatted.

*/

EXPORT_C void CTmTextLayout::SetTextL(MTmSource& aSource,const TTmFormatParam& aParam)

	{

	if (aParam.iMaxHeight <= 0 ||

		aParam.iStartChar < 0 || aParam.iEndChar < aParam.iStartChar ||

		aParam.iLineInPar < 0)

		TmPanic(EBadArg);

	if (iBdStateAtEnd)

		{

		iBdStateAtEnd->Reset();

		}

	else

		{

		iBdStateAtEnd = new(ELeave) TBidirectionalContext;

		}

	iSource = &aSource;

	iCode.Reset();

	iStartChar = aParam.iStartChar;

	CTmFormatContext::TInfo info;

	if (aParam.iFlags & TTmFormatParamBase::EWrap

		&& (aParam.iWrapWidth < 1 || aParam.iMaxHeight < 1))

		{

		// Illegal parameters, so we should not waste time formatting.

		// We will assume that good parameters will be along later.

		iHeight = 0;

		iEndChar = iStartChar;

		iWidth = 0;

		}

	else

		{

		//Get line context character from previous line if there is

		TTmDocPosSpec startDocPos(aParam.iStartChar - 1, static_cast<TTmDocPosSpec::TType>(1));

		TTmInterpreter interpreter(TTmInterpreterParam(*this));

		TBool lineFound = interpreter.DocPosToLine(startDocPos);

		if (lineFound)

			info.iContextCharPerLine = interpreter.LineContextCharChar();

		else

			info.iContextCharPerLine = NULL;

		CTmFormatContext::FormatL(aSource,aParam,iCode,info,this,NULL,iBdStateAtEnd, NULL);

		iHeight = info.iHeight;

		iEndChar = info.iEndChar;

		iWidth = 0;

		AdjustWidth(aParam,info.iWidth);

		}

	}

/**

Format part of the text that has changed and indicate whether further formatting needs to be done.

The backing text must remain constant during background formatting. What this means is that

if background formatting is enabled (TTmReformatParam::iMaxExtraLines is some small number, causing

formatting to end mid-way with TTmReformatResult::iUnformattedStart less than KMaxTInt), so that text

can be formatted bit by bit by a higher-level object, as is done by CTextView, the backing text must not

change between the series of calls to this function that make up a single reformatting act.

*/

EXPORT_C void CTmTextLayout::FormatL(const TTmFormatParamBase& aParam,const TTmReformatParam& aReformatParam,

									 TTmReformatResult& aResult)

	{

	if (!iSource)

		TmPanic(ENoSource);

	CTmReformat* reformat = CTmReformat::NewLC(*this, aParam, aReformatParam);

	reformat->ReformatL();

	CTmCode* new_code = &(reformat->NewCode());

	TTmByteCodeFinder::TInfo oldCodeInfo = reformat->ReformatRange();

	CTmFormatContext::TInfo newCodeInfo = reformat->FormatInfo();

	TBool bd_changed = reformat->BidirectionalStateChanged();

	/*

	Find the lines that have changed and need to be redisplayed.

	If aParagraphFormatChanged is true at least one paragraph format has changed,

	so the redraw rectangle includes the whole of the paragraphs affected.

	Also redraw the whole paragraph if background formatting is needed, or if the bidirectional state has changed.

	*/

	if (aReformatParam.iParFormatChanged || aResult.iUnformattedStart < KMaxTInt || bd_changed)

		{

		aResult.iRedrawRect = oldCodeInfo.iBounds;

		aResult.iRedrawRect.iBr.iY = aResult.iRedrawRect.iTl.iY + newCodeInfo.iHeight;

		}

	else

		{

		TTmInterpreterParam p(*this);

		p.iCodeStart = oldCodeInfo.iStartCodePos;

		p.iCodeEnd = oldCodeInfo.iEndCodePos;

		p.iTextStart = oldCodeInfo.iStartInfo.iStart;

		TTmInterpreter old_code_interpreter(p);

		p.iByteCode = new_code;

		p.iCodeStart = 0;

		p.iCodeEnd = new_code->Size();

		TTmInterpreter new_code_interpreter(p);

		old_code_interpreter.CalculateRedrawRect(new_code_interpreter,aReformatParam.iStartChar,

												 aReformatParam.iOldLength,aReformatParam.iNewLength,aResult.iRedrawRect);

		aResult.iRedrawRect.Move(0,oldCodeInfo.iBounds.iTl.iY);

		}

	// Delete the old bytecode and insert the new.

	iCode.ChangeL(oldCodeInfo.iStartCodePos,oldCodeInfo.iEndCodePos,*new_code);

	// Adjust the band's bounds.

	iHeight += newCodeInfo.iHeight - oldCodeInfo.iBounds.Height();

	//if the range we are replacing includes the end of the current formatted range,

	//then the end BD state pointer may be invalidated, so we need to update it

	if(oldCodeInfo.iEndInfo.iEnd == iEndChar)

		{

		*iBdStateAtEnd = reformat->BidirectionalStateAtEnd();

		}

	// Adjust the band's width if necessary.

	AdjustWidth(aParam,newCodeInfo.iWidth);

	// Adjust the band's length.

	TInt lengthOfOldRange = oldCodeInfo.iEndInfo.iEnd - oldCodeInfo.iStartInfo.iStart;

	TInt lengthOfNewRange = newCodeInfo.iEndChar - oldCodeInfo.iStartInfo.iStart;

	iEndChar += lengthOfNewRange - lengthOfOldRange;

	// Determine the change in height of the reformatted text.

	aResult.iHeightChange = newCodeInfo.iHeight - oldCodeInfo.iBounds.Height();

	/*

	Set the top of the unchanged text, and if not all text has been formatted

	remove the first unformatted line from the redraw rect.

	*/

	if (aResult.iUnformattedStart < KMaxTInt)

		{

		TTmLineInfo info;

		TTmDocPosSpec pos(aResult.iUnformattedStart,TTmDocPosSpec::ETrailing);

		DocPosToLine(pos,info);

		aResult.iRedrawRect.iBr.iY = info.iOuterRect.iTl.iY;

		ParNumberToLine(info.iParNumber,KMaxTInt,info);

		aResult.iUnchangedTop = info.iOuterRect.iBr.iY - aResult.iHeightChange;

		}

	else

		aResult.iUnchangedTop = aResult.iRedrawRect.iBr.iY - aResult.iHeightChange;

	CleanupStack::PopAndDestroy(reformat);

	Invariant();

	}

/**

Format a new paragraph immediately before or after the band and add it to the formatted text.

If the text starts or ends in the middle of the paragraph, complete the paragraph.

Return TRUE if text was successfully added, or FALSE if there is no more text to add, or

the new text would have exceeded the maximum height allowed. Place the height of the new text in aHeightIncrease.

Place the increase in the number of complete paragraphs (0 or 1) in aParagraphsIncrease.

Note that this function will not necessarily add a whole paragraph to the band: if the client has restricted

the amount of formatting to add by setting the relevant values in aParam, then these restrictions will

be respected with the result that less than a paragraph of formatting may be generated.

This is the case, for example, when CTextLayout adds text below the band. 

*/

EXPORT_C TBool CTmTextLayout::AddParL(const TTmFormatParamBase& aParam,TBool aAtStart,TInt& aHeightIncrease,

									  TInt& aParagraphsIncrease)

	{	

	if (!iSource)

		TmPanic(ENoSource);

	aHeightIncrease = 0;

	aParagraphsIncrease = 0;

	int start_char = 0;

	int end_char = 0;

	int deleted_height = 0;

	TTmFormatParam format_param(aParam);

	TBidirectionalContext* pStartBd = NULL;

	TBidirectionalContext* pEndBd = NULL;

	TBidirectionalEndOfLineContext* pEOLContext = NULL;		

	if (aAtStart)

		{

		if (iStartChar == 0)

			return FALSE;

		start_char = iSource->ParagraphStart(iStartChar - 1);

		end_char = iSource->ParagraphEnd(iStartChar - 1);

		if (end_char > iStartChar)

			{

			if (end_char > iEndChar)

				end_char = iEndChar;

			DeletePar(aParam,TRUE,KMaxTInt,deleted_height);

			}

		else

			aParagraphsIncrease = 1;

		}

	else

		{

		if (iEndChar > iSource->DocumentLength())

			return FALSE;

		start_char = iEndChar;

		end_char = iSource->ParagraphEnd(iEndChar);

		pStartBd = iBdStateAtEnd;

		pEndBd = iBdStateAtEnd;

		TInt lastLineNumber = Lines()-1;

		if(lastLineNumber >= 0)

			{

			TTmLineInfo lastLine;

			TBool found = LineNumberToLine(lastLineNumber, lastLine);

			ASSERT(found);

			if(!(lastLine.iFlags & TTmLineInfo::EParEnd))

				{

				format_param.iLineInPar = lastLine.iLineInPar+1;

				}

			}				

		aParagraphsIncrease = 1; 

		}

	CTmCode* new_code = new(ELeave) CTmCode;

	CleanupStack::PushL(new_code);

	format_param.iStartChar = start_char;

	format_param.iEndChar = end_char;

	int code_pos = aAtStart ? 0 : iCode.Size();

	CTmFormatContext::TInfo info;

	//Get line context character from previous line if there is

	TTmDocPosSpec startDocPos(format_param.iStartChar - 1, static_cast<TTmDocPosSpec::TType>(1));

	TTmInterpreter interpreter(TTmInterpreterParam(*this));

	TBool lineFound = interpreter.DocPosToLine(startDocPos);

	if (lineFound)

		info.iContextCharPerLine = interpreter.LineContextCharChar();

	else

		info.iContextCharPerLine = NULL;

	CTmFormatContext::FormatL(*iSource,format_param,*new_code,info,this,

		pStartBd, pEndBd, pEOLContext);

	// Insert the new code if any.

	aHeightIncrease = info.iHeight;

	if (aHeightIncrease > 0)

		{

		iCode.ChangeL(code_pos,code_pos,*new_code);

		iHeight += aHeightIncrease;

		if (aAtStart)

			iStartChar = start_char;

		else

			iEndChar = info.iEndChar;

		// Adjust the band's width if necessary.

		AdjustWidth(aParam,info.iWidth);

		}

	//if we did actually format to the paragraph end, reset the bd state

	if(!aAtStart)

		{

		if(iEndChar == format_param.iEndChar)

			{

			iBdStateAtEnd->Reset();

			}

		}

	CleanupStack::PopAndDestroy();	// new code

	aHeightIncrease -= deleted_height;

	Invariant();

	return aHeightIncrease > 0;

	}

TBool CTmTextLayout::LastLine(TTmLineInfo& aLine)

	{

	TInt lastLineNumber = Lines()-1;

	if(lastLineNumber >= 0)

		{

		TTmLineInfo lastLine;

		TBool found = LineNumberToLine(lastLineNumber, aLine);

		ASSERT(found);

		return ETrue;

		}

	return EFalse;	

	}

void CTmTextLayout::SetCurrentContextChar(TUint aContextChar)

	{

	iCurrentContextChar = aContextChar;

	}

TUint CTmTextLayout::GetCurrentContextChar() const

	{

	return iCurrentContextChar;

	}

/**

Extend the formatted range downwards. That is, starting at the end of the current 

formatted range, generate some new formatting and append it to the end of the range.

@param aParam 

This controls how much new formatting to generate. We will generate formatting up whichever comes first of:

- the character position specified in TTmFormatParam::iEndChar

- the height specified (in pixels) in TTmFormatParamBase::iMaxHeight

- the number of lines specified in TTmFormatParamBase::iMaxLines

We replace the values specified in TTmFormatParam::iStartChar and TmFormatParam::iLineInPar

@pre The object must have been initialised with an MTmSource, or it will panic.

*/

EXPORT_C void CTmTextLayout::ExtendFormattingDownwardsL(TTmFormatParam& aParam)

	{

	if (!iSource)

		TmPanic(ENoSource);

	aParam.iStartChar = iEndChar;

	if (iEndChar > iSource->DocumentLength())

		return;

	if (aParam.iStartChar > aParam.iEndChar)

		return;

	TBidirectionalContext* pStartBd = iBdStateAtEnd;

	TBidirectionalContext* pEndBd = iBdStateAtEnd;

	TBidirectionalEndOfLineContext* pEOLContext = NULL;		

	//if there is a last line (i.e. if there is any formatting at all)

	//and the last line is not a paragraph boundary, 

	//then initialise the line number				

	TTmLineInfo lastLine;

	TBool found = LastLine(lastLine);

	if(found && !(lastLine.iFlags & TTmLineInfo::EParEnd))

		{

		aParam.iLineInPar = lastLine.iLineInPar+1;

		}				

	//Generate the additional formatting

	CTmCode* newCode = new(ELeave) CTmCode;

	CleanupStack::PushL(newCode);

	TInt newCodePos = iCode.Size();

	CTmFormatContext::TInfo info;

	//Get line context character from previous line if there is

	TTmDocPosSpec startDocPos(aParam.iStartChar - 1, static_cast<TTmDocPosSpec::TType>(1));

	TTmInterpreter interpreter(TTmInterpreterParam(*this));

	TBool lineFound = interpreter.DocPosToLine(startDocPos);

	if (lineFound)

		info.iContextCharPerLine = interpreter.LineContextCharChar();

	else

		info.iContextCharPerLine = NULL;

	CTmFormatContext::FormatL(*iSource,aParam,*newCode,info,this,pStartBd, pEndBd, pEOLContext);

	// Insert the new code if any.

	if (info.iHeight > 0)

		{

		iCode.ChangeL(newCodePos,newCodePos,*newCode);

		iHeight += info.iHeight;

		iEndChar = info.iEndChar;

		AdjustWidth(aParam,info.iWidth);

		}

	//if we did actually format to the paragraph end, reset the bd state

	found = LastLine(lastLine);

	if(found && (lastLine.iFlags & TTmLineInfo::EParEnd))

		{

		iBdStateAtEnd->Reset();

		}

	CleanupStack::PopAndDestroy();	// new code

	Invariant();	

	}

/**

Delete the format for the first or last paragraph if its height does not exceed aMaxDeletedHeight.

Return TRUE if a paragraph was successfully deleted. Place the height of the deleted paragraph in aHeightDecrease.

*/

EXPORT_C TBool CTmTextLayout::DeletePar(const TTmFormatParamBase& aParam,TBool aAtStart,TInt aMaxDeletedHeight,

										TInt& aHeightDecrease)

	{

	aHeightDecrease = 0;

	if (!iSource || iStartChar >= iEndChar)

		return FALSE;

	int pos = aAtStart ? iStartChar : iEndChar - 1;

	TTmByteCodeFinder finder(TTmInterpreterParam(*this), pos, pos);

	TTmByteCodeFinder::TInfo info;

	if (!finder.FindByteCode(TRUE,TRUE,KMaxTInt,info))

		TmPanic(EFormatNotFound);

	if (info.iBounds.Height() > aMaxDeletedHeight)

		return FALSE;

	iCode.Delete(info.iStartCodePos,info.iEndCodePos - info.iStartCodePos);

	if (aAtStart)

		iStartChar = info.iEndInfo.iEnd;

	else

		iEndChar = info.iStartInfo.iStart;

	aHeightDecrease = info.iBounds.Height();

	iHeight -= aHeightDecrease;

	// Adjust the band's width if necessary.

	AdjustWidth(aParam,0);

	Invariant();

	return TRUE;

	}

/** 

Delete as many lines of formatting as possible from the end of the formatted range, up to 

the maximum height specified in aMaxDeletedHeight. The height decrease is placed in aHeightDecrease. 

*/

EXPORT_C void CTmTextLayout::DeleteFormattingFromEndL(const TTmFormatParamBase& aParam, TInt aMaxDeletedHeight, TInt& aHeightDecrease)

	{

	aHeightDecrease = 0;

	if (!iSource || iStartChar >= iEndChar)

		return;

	TBidirectionalContext* bdStart = new(ELeave) TBidirectionalContext;

	CleanupStack::PushL(bdStart);

	TBidirectionalContext* bdEnd = new(ELeave) TBidirectionalContext;

	CleanupStack::PushL(bdEnd);

	TTmByteCodeFinder::TInfo info;

	TTmByteCodeFinder sectionFinder(TTmInterpreterParam(*this), iStartChar, iStartChar);

	TBool found = sectionFinder.FindByteCodeAtEnd(info, aMaxDeletedHeight, iHeight, bdStart, bdEnd);

	if (!found)

		{

		CleanupStack::PopAndDestroy(2);

		}

	else

		{