/*

* 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: 

* TAGMA's bytecode interpreter classes. These convert between document positions and x-y coordinates,

* draw the text, find the bytecode for some text, and supply information about lines.

*

*/

#include "TMSTD.H"

#include "TMINTERP.H"

#include "TmHighlightSource.h"

#include <s32mem.h>

#include <frmtlay.h>

TTmInterpreterParam::TTmInterpreterParam(const CTmTextLayout& aTextLayout):

	iByteCode(&aTextLayout.Code()),

	iCodeStart(0),

	iCodeEnd(aTextLayout.Code().Size()),

	iTextStart(aTextLayout.StartChar()),

	iWidth(aTextLayout.LayoutWidth()),

	iDrawingInterpFlags(aTextLayout.GetDrawingInterpFlags())

	{

	}

TTmInterpreterParam::TTmInterpreterParam(const CTmCode& aByteCode):

	iByteCode(&aByteCode),

	iCodeStart(0),

	iCodeEnd(aByteCode.Size()),

	iTextStart(0),

	iWidth(0),

	iDrawingInterpFlags(0)

	{

	}

TTmInterpreter::TTmInterpreter(const TTmInterpreterParam& aParam,const TPoint* aTopLeft):

	iReader(*aParam.iByteCode,aParam.iCodeStart,aParam.iCodeEnd),

	iTextPos(aParam.iTextStart),

	iOp(0),

	iOpMod(0),

	iOpStartCode(0),

	iOpEndCode(0),

	iOpSubscript(0),

	iVisualEndOfLineIsAmbiguous(ETrue),

	iVisualStartOfLineIsAmbiguous(ETrue),

	iInlineTextFormat(0),

	iLabelType(MTmSource::ENoLabel),

	iBdState(NULL)

	{

	iOpStartChar = iOpEndChar = iTextPos;

	iTextLayoutWidth = aParam.iWidth;

	if (aTopLeft)

		iTextLayoutTopLeft = *aTopLeft;

	iNextLineTop = iTextLayoutTopLeft.iY;

	iNextLineStartChar = iTextPos;

	iLineInfo.iLineNumber = -1;

	iLineInfo.iParNumber = -1;

	iLineInfo.iLineInPar = -1;

	iLineInfo.iFlags = 0;

	if (0 == aParam.iTextStart)

		{

		iLineInfo.iFlags = TTmLineInfo::ELineEndsInForcedLineBreak;

		iVisualEndOfLineIsAmbiguous = EFalse;

		}

	}

/**

 * Returns ETrue if the document position is within the current line.

 * @internalComponent

 */

TBool TTmInterpreter::PosIsInLine(const TTmDocPos& aDocPos) const

	{

	if (aDocPos.iPos < iOpStartChar || iOpEndChar < aDocPos.iPos)

		return EFalse;

	if (iOpStartChar < aDocPos.iPos && aDocPos.iPos < iOpEndChar)

		return ETrue;

	if (aDocPos.iPos == iOpStartChar)

		return aDocPos.iLeadingEdge || !iVisualStartOfLineIsAmbiguous;

	// aDocPos.iPos == iOpEndChar

	return !aDocPos.iLeadingEdge && iVisualEndOfLineIsAmbiguous;

	}

/**

 * Read an operator EOpLine and its arguments from the bytecode, updating the

 * member variables accordingly.

 * @param aChars Number of characters in the line.

 * @return Number of bytes in the byte code for the line.

 * @internalComponent

 */

TInt TTmInterpreter::ReadOpLine(TInt aChars)

	{

	iVisualStartOfLineIsAmbiguous = iVisualEndOfLineIsAmbiguous;

	iLineInfo.iLineNumber++;

	iLineInfo.iLineInPar++;

	iLineInfo.iFlags = 0;

	if (iOpMod & EModParStart)

		{

		iVisualStartOfLineIsAmbiguous = EFalse;

		iLineInfo.iParNumber++;

		iLineInfo.iLineInPar = 0;

		iLineInfo.iParTop = iNextLineTop;

		iLineInfo.iFlags |= TTmLineInfo::EParStart;

		}

	if (iOpMod & EModParEnd)

		iLineInfo.iFlags |= TTmLineInfo::EParEnd;

	TInt flags = 0;

	if (iOpMod & EModLineFlags)

		flags = iReader.ReadNumber(); // <F> (flags)

	if (flags & ELineFlagLineEndsInForcedLineBreak)

		iLineInfo.iFlags |= TTmLineInfo::ELineEndsInForcedLineBreak;

	iVisualEndOfLineIsAmbiguous = flags & ELineFlagVisualEndOfLineIsAmbiguous;

	if (iOpMod & EModRightToLeft)

		iLineInfo.iFlags |= TTmLineInfo::EParRightToLeft;

	TInt extra_bytes = iReader.ReadNumber(); // <B> (bytecode size)

	// Set line information; read height <H> and inner rect <I> and make band-relative

	iLineInfo.iStart = iOpStartChar = iNextLineStartChar;

	iLineInfo.iEnd = iOpEndChar = iNextLineStartChar = iOpStartChar + aChars;

	iLineInfo.iOuterRect.iTl.iX = iTextLayoutTopLeft.iX;

	iLineInfo.iOuterRect.iBr.iX = iTextLayoutTopLeft.iX + iTextLayoutWidth;

	iLineInfo.iOuterRect.iTl.iY = iNextLineTop;

	iNextLineTop += iReader.ReadNumber();				// <H> (height)

	iLineInfo.iOuterRect.iBr.iY = iNextLineTop;

	iLineInfo.iInnerRect = iReader.ReadRect();			// <I> (inner rectangle)

	iLineInfo.iInnerRect.Move(iLineInfo.iOuterRect.iTl);

	iLineInfo.iBaseline = iLineInfo.iInnerRect.iTl.iY + iReader.ReadNumber();	// <A> (ascent)

	// Set the start and end pen positions

	iOpStartPen = iLineInfo.iInnerRect.iTl;

	iOpStartPen.iY = iLineInfo.iBaseline;

	iOpEndPen = iLineInfo.iInnerRect.iBr;

	iOpEndPen.iY = iLineInfo.iBaseline;

	// Read the bidirectional state immediately if it is present and is wanted (iBdState is non-null)

	//first reset the bidirectional state pointer - if the state is not present in the

	//bytecode that means that it's the default state

	if(iBdState)

		{

		iBdState->Reset();

		}

	while (iBdState && iReader.CodePos() < iReader.CodeEndPos()

		&& iReader.PeekByte() == EOpParam)

		{

		TInt end_code = iReader.CodePos() + extra_bytes;

		iReader.ReadByte(); // skip EOpParam

		TUint8 id = iReader.ReadByte();

		TInt bytes = iReader.ReadNumber();

		if (id == EParamBdState)

			{

			RBufReadStream stream(*iReader.Code().Buffer(),iReader.CodePos());

			TRAPD(error,iBdState->InternalizeL(stream));

			if (error)

				Panic(ECorrupt);

			stream.Close();

			}

		Skip(iReader.CodePos() + bytes,iOpStartChar);

		extra_bytes = end_code - iReader.CodePos();

		}

	// Set the interpreter text and pen positions.

	iPen = iOpStartPen;

	iTextPos = iOpStartChar;

	return extra_bytes;

	}

/** Read an operator and its arguments from the bytecode, updating the member

variables accordingly. Note that the current position in the byte code is

not necessarily brought up to the next operator.

@pre The current position in the byte code is at an operator.

@return EFalse if there was insufficient byte code to read.

@internalComponent */

TBool TTmInterpreter::Next()

	{

	if (iReader.CodePos() >= iReader.CodeEndPos())

		return FALSE;

	// Initialise start character, pen position and code position.

	iOpStartChar = iTextPos;

	iOpStartPen = iPen;

	iOpStartCode = iReader.CodePos();

	// Unpack the operator.

	iOp = iOpMod = iReader.ReadByte();

	iOp &= KMaskOpcode;	// top three bits

	iOpMod &= KMaskModifiers; // low five bits

	TInt chars = 1;

	iOpSubscript = 0;

	if (iOp == EOpLine)

		{

		chars = iReader.ReadNumber();

		iLineContextChar = iReader.ReadNumber();	// Read the context  for this line 

		}

	else

		{

		// Read optional arguments <P>, <N> and <Y>

		if (iOpMod & EModPos)

			iOpStartChar += iReader.ReadNumber();

		if (iOpMod & EModCount)

			chars = iReader.ReadNumber();

		if (iOpMod & EModSubscript)

			iOpSubscript = iReader.ReadNumber();

		}

	iOpEndChar = iOpStartChar + chars;

	iOpEndPen = iOpStartPen;

	TInt extra_bytes = 0;

	switch (iOp)

		{

		case EOpLine:

			extra_bytes = ReadOpLine(chars);

			break;

		case EOpText:

		case EOpSpecialChar:

				{

				TInt deltaX = iReader.ReadNumber();

				if (0 <= deltaX)

					iOpEndPen.iX += deltaX;

				else

					iOpStartPen.iX += deltaX;

				}

			iContextChar = iReader.ReadNumber();	// Read the context  for this chunk.

			iTextPos = iOpEndChar;

			iPen.iX = iOpEndPen.iX;

			break;

		case EOpInlineText:

			iOpEndPen.iX += iReader.ReadNumber();

			iInlineTextFormat = iReader.ReadNumber();

			{

			iInlineText.SetLength(chars + 2);

			iInlineText[0] = 0xFFFF;

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

				iInlineText[i+1] = (TText)iReader.ReadNumber();

			iInlineText[chars+1] = 0xFFFF;

			}

			iOpEndChar = iOpStartChar;

			iTextPos = iOpEndChar;

			iPen.iX = iOpEndPen.iX;

			break;

		case EOpRule:

			iBounds = iReader.ReadRect();

			iBounds.Move(iOpStartPen);

            iRuleColour = TRgb(iReader.ReadNumber());

			break;

		case EOpDoc:

			extra_bytes = iReader.ReadNumber(); // <B> (bytecode size)

			iBounds = iReader.ReadRect();		// <R> (bounds)

			iBounds.Move(iOpStartPen);

			iOpEndPen.iX = iBounds.iBr.iX;

			break;

		case EOpLabel:

			extra_bytes = iReader.ReadNumber(); // <B> (bytecode size)

			iBounds = iReader.ReadRect();		// <R> (bounds)

			iLabelType = (MTmSource::TLabelType)iReader.ReadNumber();	// <L> (label type)

			break;

		case EOpParam:

			iParamId = iReader.ReadByte();

			iOpEndChar = iOpStartChar;			// parameters consume no text

			extra_bytes = iReader.ReadNumber(); // <B> (bytecode size)

			break;			

		default:

			Panic(ECorrupt);

			break;

		}

	iOpEndCode = iReader.CodePos() + extra_bytes;

	return TRUE;

	}

/**

 * Sets the position within the byte code.

 * @param aCodePos The position within the byte code to go to.

 * @param aTextPos The document position that corresponds to aCodePos.

 * @internalComponent

 */

void TTmInterpreter::Skip(TInt aCodePos,TInt aTextPos)

	{

	iReader.SetCodePos(aCodePos);

	iTextPos = aTextPos;

	}

/** Returns the picture subscript value */

TInt TTmInterpreter::Subscript()

	{

	return iOpSubscript;

	}

/**

@internalComponent

*/

RTmGeneralInterpreter::RTmGeneralInterpreter(MTmSource& aSource,

	const TTmInterpreterParam& aParam, const TPoint* aTopLeft)

	: TTmInterpreter(aParam,aTopLeft),

	iTextCache(aSource,aSource.InterpretDevice())

	{ 

	iCopyFit = &aSource.InterpretDevice() != &aSource.FormatDevice(); 

	iTmTextDrawExt = reinterpret_cast <MTmTextDrawExt*> (Source().GetExtendedInterface(KTmTextDrawExtId));

	if(!iTmTextDrawExt)

		{

		iTmTextDrawExt = &iTmTextDrawExtDefault;

		}

	}

/**

 * Get source text starting at aPos and not more than (aEndChar - aPos)

 * characters.

 * @param aPos The start position for the text to be returned.

 * @param aEndChar The maximum position to be returned plus one.

 * @param aText Returns a view of the text.

 * @param aFormat

 *		If non-null, returns the format of this text. All the text returned is

 *		in this format.

 * @param aFont If aFont is not null, on return contains a pointer to an opened CTmTextFontCache*

			The caller must call Close on aFont when finished with the font.

 * @internalComponent

 */

void RTmGeneralInterpreter::GetText(TInt aPos,TInt aEndChar,TPtrC& aText,TTmCharFormat* aFormat,CTmTextFontCache** aFont)

	{

	iTextCache.GetText(aPos,aEndChar,aText,aFormat,aFont);

	}

/**

 * Gets the inline text inserted by the formatter in the current position.

 * @param aText Returns the inline text. Valid until the position is moved.

 * @param aFormat If non-null, returns the format of the inline text.

 * @param aFont If aFont is not null, on return contains a pointer to an opened CTmTextFontCache*

			The caller must call Close on aFont when finished with the font.

 * @internalComponent

 */

void RTmGeneralInterpreter::GetInlineText(TPtrC& aText,TTmCharFormat* aFormat,CTmTextFontCache** aFont)

	{

	TPtrC p;

    TInt inlineTextFormatPos = InlineTextFormat() + LineInfo().iStart;

    //InlineTextFormat(): the offset position in current line

    //LineInfo().iStart : start position of current line

    //inlineTextFormatPos : position in the whole document 

    iTextCache.GetText(inlineTextFormatPos,KMaxTInt,p,aFormat,aFont);

	aText.Set(InlineText());

	}

/**

 * Returns the number of lines in the band.

 * @return Number of lines formatted.

 * @internalComponent

 */

TInt TTmInterpreter::Lines()

	{

	while (Next())

		{

		__ASSERT_ALWAYS(Op() == EOpLine, Panic(ECorrupt));

		Skip();

		}

	return iLineInfo.iLineNumber + 1;

	}

/**

 * Returns the number of paragraphs in the band.

 * @return Number of paragraphs formatted.

 * @internalComponent

 */

TInt TTmInterpreter::Paragraphs()

	{

	while (Next())

		{

		__ASSERT_ALWAYS(Op() == EOpLine, Panic(ECorrupt));

		Skip();

		}

	return iLineInfo.iParNumber + 1;

	}

/**

 * Iterates to the line containing the document position if any. Any position

 * from CTmTextLayout::StartChar() to CTmTextLayout::EndChar() inclusive can be

 * found.

 * @param aDocPos The document position to be found.

 * @return ETrue if it was found.

 * @internalComponent

 */

TBool TTmInterpreter::DocPosToLine(const TTmDocPosSpec& aDocPos)

	{

	/*

	Convert to a document position. Treat positions specified using directionality as

	trailing, then correct to the following line if necessary.

	*/

	TTmDocPos doc_pos(aDocPos.iPos,aDocPos.iType == TTmDocPosSpec::ELeading);

	if (!Next())

		return EFalse;

	__ASSERT_ALWAYS(Op() == EOpLine, Panic(ECorrupt));

	while  (!PosIsInLine(doc_pos))

		{

		Skip();

		if (!Next())

			return EFalse;

		__ASSERT_ALWAYS(Op() == EOpLine, Panic(ECorrupt));

		}

	/*

	If the position is at the end of the line and was sought by direction it might not be in the line;

	if not it will be in the next line if any. Read operators and check for the position until it is

	found or we get to the next line.

	*/

	if (aDocPos.iPos == EndChar()

		&& aDocPos.iType != TTmDocPosSpec::ETrailing

		&& aDocPos.iType != TTmDocPosSpec::ELeading

		&& !AtEndOfTextLayout())

		{

		TBool rightToLeft = (aDocPos.iType == TTmDocPosSpec::ERightToLeft);

		while (Next() && Op() != EOpLine)

			{

			TBool sameDirectionality = rightToLeft?

				RightToLeft() : !RightToLeft();

			if (aDocPos.iPos == EndChar() && sameDirectionality)

				return ETrue;

			}

		}

	return ETrue;

	}

/**

 * Iterates to the line with the specified line number if any.

 * @param aLineNumber The line number to find.

 * @return ETrue if the line was found (i.e. if it is formatted).

 * @internalComponent

 */

TBool TTmInterpreter::LineNumberToLine(TInt aLineNumber)

	{

	while (Next())

		{

		__ASSERT_ALWAYS(Op() == EOpLine, Panic(ECorrupt));

		if (iLineInfo.iLineNumber == aLineNumber)

			return TRUE;

		else

			Skip();

		}

	return EFalse;

	}

/**

 * Iterates to the specified line of the specified paragraph. This function

 * will always return ETrue if the paragraph is formatted. If the line number

 * is out of range it will be camped to the correct range; thus if aLineInPar

 * is KMaxTInt the last line of the paragraph is found.

 * @param aParNumber Paragraph number to be found.

 * @param aLineInPar Line number within paragraph to be found.

 * @return

 *		ETrue if the operation is successful. This will be the case if the

 *		applicable line is formatted.

 * @internalComponent

 */

TBool TTmInterpreter::ParNumberToLine(TInt aParNumber,TInt aLineInPar)

	{

	while (Next())

		{

		__ASSERT_ALWAYS(Op() == EOpLine, Panic(ECorrupt));

		if (iLineInfo.iParNumber == aParNumber)

			{

			if (iLineInfo.iLineInPar >= aLineInPar || ParEnd())

				return TRUE;

			}

		Skip();

		}

	return EFalse;

	}

/**

 * Iterates to the line containing the specified Y position number if any.