/*

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

 * CTextLayout implementation using the TAGMA text formatting system.

 *

 */

 #include <txtlaydc.h>

 #include "FRMTLAY.H"

 #include "FRMCONST.H"

 #include "FORMUTIL.H"

 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

 #include "FRMCONST_INTERNAL.H"

 #include "FRMCONST_PARTNER.H"

 #include "TAGMA_INTERNAL.H"

 #include "FRMTLAY_INTERNAL.H"

 #endif

 #include "OstTraceDefinitions.h"

 #ifdef OST_TRACE_COMPILER_IN_USE

 #include "LAYEMUTraces.h"

 #endif

 const TInt KMaxExtraLines = 10; // maximum number of lines to format after the current and following lines

 								// before using background formatting

 // during page down/up, the number of lines that should remain visible after

 // the scroll, counting from the first line that is not completely visible.

 // i.e. setting this to 0 means always scroll KMaxProportionOfScreenToScroll.

 // setting it to 1 means make sure that no lines are ever both partially off the

 // top/bottom before the scroll and partially visible off the bottom/top after

 // the scroll.

 // setting it to any number higher means keep that number -1 lines completely

 // visible before and after the scroll.

 const TInt KNumberOfLinesToKeepVisibleDuringScroll = 2;

 /** maximum scroll proportions in thousandths. This overrides

  the KNumberOfLinesToKeepVisibleDuringScroll constant.*/

 const TInt KMaxProportionOfScreenToScroll = 1000;

 /** minimum scroll proportions in thousandths. This overrides

  the KNumberOfLinesToKeepVisibleDuringScroll constant.*/

 const TInt KMinProportionOfScreenToScroll = 600;

 /**

 Constructs an iterator over the text referenced by aSource.

 @param aSource The source of the text to be iterated over.

 */

 CTextLayout::TUtf32SourceCache::TUtf32SourceCache(const MTmSource& aSource)

 	: iSource(&aSource), iCurrentViewIndex(-1)

 	{

 	}

 /**

 Constructs an iterator over the text formatted by aLayout.

 @param aLayout The formatter of the text to be iterated over.

 */

 CTextLayout::TUtf32SourceCache::TUtf32SourceCache(const CTextLayout& aLayout)

 	: iSource(aLayout.iSource), iCurrentViewIndex(-1)

 	{

 	}

 /**

 Gets the specified character without uniting surrogate pairs.

 @param aIndex The document position to retrieve.

 @pre 0 <= aIndex && aIndex < {document length}

 */

 TText CTextLayout::TUtf32SourceCache::GetUtf16(TInt aIndex)

 	{

 	TTmCharFormat dummy;

 	if (aIndex < iCurrentViewIndex)

 		{

 		iCurrentViewIndex = 0;

 		iSource->GetText(iCurrentViewIndex, iCurrentView, dummy);

 		}

 	TInt currentViewEnd = iCurrentViewIndex + iCurrentView.Length();

 	while (currentViewEnd <= aIndex)

 		{

 		TInt difference = aIndex - iCurrentViewIndex;

 		TInt newIndex = aIndex - (difference >> 1);

 		iCurrentViewIndex = newIndex < currentViewEnd?

 			currentViewEnd : newIndex;

 		iSource->GetText(iCurrentViewIndex, iCurrentView, dummy);

 		currentViewEnd = iCurrentViewIndex + iCurrentView.Length();

 		}

 	return iCurrentView[aIndex - iCurrentViewIndex];

 	}

 /**

 Gets the specified character, uniting surrogate pairs if appropriate.

 @param aIndex

 	The document position to retrive.

 @return

 	The character at position aIndex. If aIndex is at the first code of a

 	surrogate pair, the full character is returned. If it is the second of a

 	valid surrogate pair or an unpaired surrogate, the surrogate is returned.

 */

 TChar CTextLayout::TUtf32SourceCache::GetUtf32(TInt aIndex)

 	{

 	TText code = GetUtf16(aIndex);

 	if (TChar::IsHighSurrogate(code) && iSource->DocumentLength() < aIndex + 1)

 		{

 		TText code2 = GetUtf16(aIndex + 1);

 		if (TChar::IsLowSurrogate(code2))

 			return TChar::JoinSurrogate(code, code2);

 		}

 	return code;

 	}

 /** Allocates and constructs a CTextLayout object. By default, the formatting

 is set to the entire document (EFFormatAllText).

 The text needs to be reformatted after a call to this function.

 @param aDoc Pointer to the MLayDoc implementation that is the source of the

 text and formatting information. Must not be NULL or a panic occurs.

 @param aWrapWidth The wrapping width in pixels.

 @return Pointer to the new CTextLayout object. */

 EXPORT_C CTextLayout *CTextLayout::NewL(MLayDoc *aLayDoc,TInt aWrapWidth)

 	{

 	CTextLayout* t = new(ELeave) CTextLayout;

 	CleanupStack::PushL(t);

 	t->ConstructL(aLayDoc,aWrapWidth);

 	CleanupStack::Pop();

 	return t;

 	}

 EXPORT_C CTextLayout::CTextLayout():

 	iText(NULL),

 	iExcessHeightRequired(0),

 	iWnd(NULL),

 	iBeginRedrawCount(0),

 	iRedrawRect(),

 	iTextViewCursorPos(NULL),

 	iIsWndInExternalRedraw(EFalse),

 	iUnformattedStart(KMaxTInt),

 	iHighlightExtensions(NULL),

 	iSource(NULL)

 	{

 	}

 /** Constructs an object with a text source of aLayDoc and a wrap width of

 aWrapWidth, with wrapping turned on.

 */

 EXPORT_C void CTextLayout::ConstructL(MLayDoc *aLayDoc,TInt aWrapWidth)

 	{

 	iHighlightExtensions = new(ELeave) TTmHighlightExtensions;

 	CleanupStack::PushL(iHighlightExtensions);

 	iHighlightExtensions->SetAll(0);

 	iText = new(ELeave) CTmTextLayout;

 	CleanupStack::PushL(iHighlightExtensions);

 	iSource = new(ELeave) TLayDocTextSource;

 	iSource->iLayDoc = aLayDoc;

 	SetWrapWidth(aWrapWidth);

 	SetAmountToFormat(EFFormatAllText);

 	CleanupStack::Pop(2);

 	}

 EXPORT_C CTextLayout::~CTextLayout()

 	{

 	delete iHighlightExtensions;

 	iHighlightExtensions = NULL;

 	delete iText;

 	iText = NULL;

 	delete iSource;

 	iSource = NULL;

 	}

 void CTextLayout::SetWindow(RWindow* aWnd)

 	{

 	iWnd = aWnd;

 	}

 void CTextLayout::SetReadyToRedraw()

 	{

 	iReadyToRedraw = ETrue;

 	}

 void CTextLayout::BeginRedraw(const TRect& aRect)

 	{

 	if(!iReadyToRedraw)

 		return;

 	if (0 == iBeginRedrawCount++)

 		{

 		iRedrawRect = aRect;

 		if (NULL != iWnd)

 			{

 			if (iWnd->GetDrawRect() == TRect::EUninitialized)

 				{

 				iWnd->Invalidate(aRect);

 				iWnd->BeginRedraw(aRect);

 				}

 				else

 					iIsWndInExternalRedraw = ETrue;

 			}

 		}

 	}

 void CTextLayout::EndRedraw()

 	{

 	if(!iReadyToRedraw)

 		return;

 	if (iBeginRedrawCount <= 0)

 	    {

 	    OstTrace0( TRACE_DUMP, CTEXTLAYOUT_ENDREDRAW, "CTextLayout::EndRedraw" );

 	    }

 	__ASSERT_ALWAYS(iBeginRedrawCount > 0, Panic(EInvalidRedraw));

 	if (0 == --iBeginRedrawCount)

 		{

 		if (NULL != iWnd)

 			{

 			if (!iIsWndInExternalRedraw)

 				{

 				iWnd->EndRedraw();

 				iRedrawRect = TRect();

 				}

 				else

 					iIsWndInExternalRedraw = EFalse;

 			}

 		}

 	}

 void CTextLayout::SetExternalDraw(const TRect& aRect)

 	{

 	if (0 != iBeginRedrawCount)

 	    {

 	    OstTrace0( TRACE_FATAL, DUP1_CTEXTLAYOUT_SETEXTERNALDRAW, "EInvalidRedraw" );

 	    }

 	__ASSERT_ALWAYS(0 == iBeginRedrawCount, Panic(EInvalidRedraw));

 	iBeginRedrawCount++;

 	iRedrawRect = aRect;

 	}

 void CTextLayout::ResetExternalDraw()

 	{

 	if (1 != iBeginRedrawCount)

 	    {

 	    OstTrace0( TRACE_FATAL, CTEXTLAYOUT_RESETEXTERNALDRAW, "EInvalidRedraw" );

 	    }

 	__ASSERT_ALWAYS(1 == iBeginRedrawCount, Panic(EInvalidRedraw));

 	iBeginRedrawCount--;

 	iRedrawRect = TRect();

 	}

 TBool CTextLayout::BeginRedrawCalled() const

 	{

 	return iBeginRedrawCount > 0;

 	}

 /** Discards all formatting information. This function is used by the CTextView

 and the printing classes, but should be called by higher-level classes that

 need to clean up after any CTextLayout function has caused an out-of-memory

 exception. */

 EXPORT_C void CTextLayout::DiscardFormat()

 	{

 	iText->Clear();

 	iBandTop = 0;

 	}

 TInt CTextLayout::SetBandTop()

 	{

 	TInt originalBandTop = iBandTop;

 	if (iScrollFlags & EFScrollOnlyToTopsOfLines)

 		{

 		TTmLineInfo line;

 		if (iText->YPosToLine(iBandTop, line))

 			iBandTop = line.iOuterRect.iTl.iY;

 		}

 	return originalBandTop - iBandTop;

 	}

 /** Sets the layout object's source text to aDoc.

 The text needs to be reformatted after a call to this function.

 @param aDoc Pointer to the MLayDoc implementation that is the source of the

 text and formatting information. Must not be NULL or a panic occurs. */

 EXPORT_C void CTextLayout::SetLayDoc(MLayDoc *aLayDoc)

 	{

 	iSource->iLayDoc = aLayDoc;

 	}

 /** Sets the wrap width. If the current format mode is screen mode

 (CLayoutData::EFScreenMode) aWrapWidth is in pixels, otherwise it is in twips.

 The text needs to be reformatted after a call to this function.

 Note:

 A valid wrap width (>0) must be supplied or the expected amount of formatting will 

 not take place. This could lead to panics when trying to retrieve formatting 

 information that does not exist.

 @param aWrapWidth The wrap width in pixels or twips. */

 EXPORT_C void CTextLayout::SetWrapWidth(TInt aWrapWidth)

 	{

 	if (iSource->iFormatMode == CLayoutData::EFScreenMode)

 		iSource->iWidth = aWrapWidth;

 	else

 		iSource->iWidth = iSource->iFormatDevice->HorizontalTwipsToPixels(aWrapWidth);

 	}

 /** Sets the height of the band in pixels or twips. This is the height of the

 visible text, or the view window, and it is also the page height for the

 purposes of scrolling up and down by page. If the current mode is screen mode 

 (CLayoutData::EFScreenMode) or what-you-see-is-what-you-get mode 

 (CLayoutData::EFWysiwygMode), aHeight is in pixels, otherwise it is in twips.

 The text needs to be reformatted after a call to this function. 

 Note:

 A valid band height (>0) must be supplied or the expected amount of formatting will 

 not take place. This could lead to panics when trying to retrieve formatting 

 information that does not exist.

 @param aHeight The band height in pixels or twips. */

 EXPORT_C void CTextLayout::SetBandHeight(TInt aHeight)

 	{

 	iVisibleHeight = aHeight;

 	if (iBandHeight != CLayoutData::EFHeightForFormattingAllText || aHeight < 1)

 		iBandHeight = aHeight;

 	}

 /** Gets the height of the band in pixels or twips.

 @return The height of the band in pixels or twips. */

 EXPORT_C TInt CTextLayout::BandHeight() const

 	{

 	return VisibleHeightInPixels();

 	}

 /** Sets the device map used for drawing and formatting. This device map is

 also used for formatting and drawing paragraph labels unless a separate label

 device map has been set (see SetLabelsDeviceMap()).

 The text needs to be reformatted after a call to this function.

 Note:

 Although the name of the function suggests that only the image device is set,

 the formatting device is also set.

 @param aGd The device map used for drawing and formatting. */

 EXPORT_C void CTextLayout::SetImageDeviceMap(MGraphicsDeviceMap *aDeviceMap)

 	{

 	iSource->iImageDevice = aDeviceMap;

 	iSource->iFormatDevice = aDeviceMap;

 	}

 /** Sets the device map used for formatting and drawing paragraph labels. If

 not set, the device map used for labels will be the same as that used for the

 text.

 The text needs to be reformatted after a call to this function.

 @param aDeviceMap The device map used for formatting and drawing paragraph

 labels. */

 EXPORT_C void CTextLayout::SetLabelsDeviceMap(MGraphicsDeviceMap *aDeviceMap)

 	{

 	iSource->iLabelsDevice = aDeviceMap;

 	}

 /** Sets whether to format all the text (if aAmountOfFormat is

 EFFormatAllText), or just the visible band (if aAmountOfFormat is

 EFFormatBand). If band formatting is selected, enough text is formatted to fill

 the visible height.

 The text needs to be reformatted after a call to this function.

 @param aAmountOfFormat CTextLayout::EFFormatBand (the default) to format the

 visible text only. CTextLayout::EFFormatAllText to format all the text in the

 document. */

 EXPORT_C void CTextLayout::SetAmountToFormat(TAmountFormatted aAmountOfFormat)

 	{

 	if (aAmountOfFormat == EFFormatBand)

 		iBandHeight = iVisibleHeight;

 	else

 		iBandHeight = CLayoutData::EFHeightForFormattingAllText;

 	}

 /** Tests whether band formatting is on, as set by

 CTextLayout::SetAmountToFormat().

 @return ETrue if band formatting is on, EFalse if not. */

 EXPORT_C TBool CTextLayout::IsFormattingBand() const

 	{

 	return iBandHeight != CLayoutData::EFHeightForFormattingAllText;

 	}

 /** Sets the format mode and wrap width and (for certain format modes only)

 sets the formatting device.

 The text needs to be reformatted after a call to this function.

 Notes:

 If aFormatMode is CLayoutData::EFWysiwygMode or

 CLayoutData::EFPrintPreviewMode, the format device is set to aFormatDevice,

 which must not be NULL.

 If aFormatMode is CLayoutData::EFScreenMode or CLayoutData::EFPrintMode,

 aFormatDevice is ignored and should be NULL; the format device is set to the

 image device.

 The wrap width is set in either twips or pixels using the same rule as for

 SetWrapWidth().

 @param aFormatMode The format mode.

 @param aWrapWidth The wrap width in pixels or twips.

 @param aFormatDevice The formatting device or NULL, depending on the format

 mode. */

 EXPORT_C void CTextLayout::SetFormatMode(CLayoutData::TFormatMode aFormatMode,TInt aWrapWidth,

 										 MGraphicsDeviceMap* aFormatDevice)

 	{

 	if (aFormatMode == CLayoutData::EFWysiwygMode || aFormatMode == CLayoutData::EFPrintPreviewMode)

 		{

 		if (aFormatDevice == NULL)

 		    {

 		    OstTrace0( TRACE_FATAL, CTEXTLAYOUT_SETFORMATMODE, "EFormatDeviceNotSet" );

 		    }

 		__ASSERT_ALWAYS(aFormatDevice != NULL,Panic(EFormatDeviceNotSet));

 		iSource->iFormatDevice = aFormatDevice;

 		}

 	else

 		iSource->iFormatDevice = iSource->iImageDevice;

 	iSource->iFormatMode = aFormatMode;

 	SetWrapWidth(aWrapWidth);

 	}

 /** Turns wrapping on (if aNoWrapping is EFParagraphsWrappedByDefault) or off

 (if aNoWrapping is EFAllParagraphsNotWrapped). Overrides the paragraph format

 when wrapping is turned off -paragraphs are not broken into lines even if the

 iWrap member of CParaFormat is ETrue. If wrapping is turned on,

 CParaFormat::iWrap is honoured.

 The text needs to be reformatted after a call to this function.

 @param aNoWrapping EFAllParagraphsNotWrapped (the default) to turn wrapping

 off, EFParagraphsWrappedByDefault to turn wrapping on. */

 EXPORT_C void CTextLayout::ForceNoWrapping(TBool aNoWrapping)

 	{

 	if (aNoWrapping)

 		iSource->iFlags &= ~TLayDocTextSource::EWrap;

 	else

 		iSource->iFlags |= TLayDocTextSource::EWrap;

 	}

 /** Tests whether wrapping is on or off.

 @return ETrue if wrapping is on, EFalse if off. */

 EXPORT_C TBool CTextLayout::IsWrapping() const

 	{

 	return (iSource->iFlags & TLayDocTextSource::EWrap) != 0;

 	}

 /** Sets the truncation mode. If truncation is on, lines that exceed the wrap

 width, either because they have no legal line break, or because wrapping is

 off, are truncated, and an ellipsis is inserted.

 @param aOn If ETrue, lines which extend beyond the wrap width are truncated

 with an ellipsis character. If EFalse, no ellipsis is used. */

 EXPORT_C void CTextLayout::SetTruncating(TBool aOn)

 	{

 	if (aOn)

 		iSource->iFlags |= TLayDocTextSource::ETruncateWithEllipsis;

 	else

 		iSource->iFlags &= ~TLayDocTextSource::ETruncateWithEllipsis;

 	}

 /** Tests whether truncation is on (as set by SetTruncating()).

 @return ETrue if truncation is on, EFalse if not. */

 EXPORT_C TBool CTextLayout::Truncating() const

 	{

 	return (iSource->iFlags & TLayDocTextSource::ETruncateWithEllipsis) != 0;

 	}

 /** Sets the ellipsis character to be used if truncation is on. Specify the

 value 0xFFFF (the illegal Unicode character) if no ellipsis character should

 be used. By default, the ellipsis character is 0x2026, the ordinary horizontal

 ellipsis.

 @param aEllipsis The Unicode value of the truncating ellipsis character. */

 EXPORT_C void CTextLayout::SetTruncatingEllipsis(TChar aEllipsis)

 	{

 	iSource->iEllipsis = aEllipsis;

 	}

 /** Returns the ellipsis character used when truncation is on. The value 0xFFFF

 (the illegal Unicode character) means that no ellipsis character is appended to

 truncated text.

 @return The Unicode value of the truncating ellipsis character. */

 EXPORT_C TChar CTextLayout::TruncatingEllipsis() const

 	{

 	return iSource->iEllipsis;

 	}

 /** Sets the width in pixels of the margin in which labels are drawn.

 The text needs to be reformatted after a call to this function.

 @param aWidth The width in pixels of the labels margin. */

 EXPORT_C void CTextLayout::SetLabelsMarginWidth(TInt aWidth)

 	{

 	iSource->iLabelsWidth = aWidth;

 	}

 /** Specifies which non-printing characters (e.g. space, paragraph break, etc.)

 are to be drawn using symbols.

 The text needs to be reformatted after a call to this function.(because

 non-printing characters may differ in width from their visible

 representations).

 @param aVisibility Indicates which non-printing characters are drawn using

 symbols. */

 EXPORT_C void CTextLayout::SetNonPrintingCharsVisibility(TNonPrintingCharVisibility aVisibility)

 	{

 	iSource->iNonPrintingCharVisibility = aVisibility;

 	}

 /** Returns which non-printing characters are drawn using symbols.

 @return Indicates which non-printing characters are drawn using symbols. */

 EXPORT_C TNonPrintingCharVisibility CTextLayout::NonPrintingCharsVisibility() const

 	{

 	return iSource->iNonPrintingCharVisibility;

 	}

 /** Tests whether background formatting is currently taking place. Background

 formatting is managed by CTextView, using an active object, when the

 CTextLayout object is owned by a CTextView object.

 Not generally useful.

 @return ETrue if background formatting is currently taking place. EFalse if not.

 */

 EXPORT_C TBool CTextLayout::IsBackgroundFormatting() const

 	{

 	return iUnformattedStart < KMaxTInt;

 	}

 /** CTextView calls this function when background formatting has ended. It

 allows the CTextLayout object to discard information used only during

 background formatting.

 Not generally useful. */

 EXPORT_C void CTextLayout::NotifyTerminateBackgroundFormatting()

 	{

 	iUnformattedStart = KMaxTInt;

 	}

 /** Specifies whether partially displayed lines (at the top and bottom of

 the view) are to be prevented from being drawn, and whether the top of

 the display is to be aligned to the nearest line.

 This function takes effect only when the text is next formatted or

 scrolled.Note:This function was designed for non-editable text in the

 Agenda application, and there is an important restriction:

 CTextView functions that reformat the text after editing must not be used

 while partial lines are excluded; these functions are 

 CTextView::HandleCharEditL(),

 CTextView::HandleInsertDeleteL() and

 CTextView::HandleRangeFormatChangeL().

 @param aExcludePartialLines ETrue (the default) to exclude partially

 displayed lines from the view. EFalse to include them.

 @deprecated 7.0 */

 //It did not work, and it was not what the customer wanted. A more comprehensive

 //solution is being considered.

 EXPORT_C void CTextLayout::SetExcludePartialLines(TBool) {}

 /** Tests whether partial lines at the top and bottom of the view are

 currently excluded.

 @return ETrue if partial lines are excluded, EFalse if they are displayed.

 @deprecated 7.0 */

 EXPORT_C TBool CTextLayout::ExcludingPartialLines() const

 	{

 	return EFalse;

 	}

 /** Sets the percentage by which font heights are increased in order to provide

 automatic extra spacing (leading) between lines. This amount is set to

 CLayoutData::EFFontHeightIncreaseFactor, which is 7, when a CTextLayout object

 is created.

 The text needs to be reformatted after a call to this function.

 @param aPercentage Factor by which to increase font heights. */

 EXPORT_C void CTextLayout::SetFontHeightIncreaseFactor(TInt aPercentage)

 	{

 	iSource->iFontHeightIncreaseFactor = aPercentage;

 	}

 /** Returns the font height increase factor as a percentage (i.e. a return

 value of 7 means that font heights are increased by 7% to provide automatic

 extra spacing between lines).

 @return Factor by which font heights are increased. */

 EXPORT_C TInt CTextLayout::FontHeightIncreaseFactor() const

 	{

 	return iSource->iFontHeightIncreaseFactor;

 	}

 /** Sets the minimum line descent in pixels. This amount is set to

 CLayoutData::EFMinimumLineDescent, which is 3, when a CTextLayout object is

 created.

 The text needs to be reformatted after a call to this function.

 @param aPixels The minimum line descent in pixels. */

 EXPORT_C void CTextLayout::SetMinimumLineDescent(TInt aPixels)

 	{

 	iSource->iMinimumLineDescent = aPixels;

 	}

 /** Returns the minimum line descent in pixels.

 @return The minimum line descent in pixels. */

 EXPORT_C TInt CTextLayout::MinimumLineDescent() const

 	{

 	return iSource->iMinimumLineDescent;

 	}

 /** Returns the document length in characters, including all the text, not just

 the formatted portion, but not including the final paragraph delimiter (the

 "end-of-text character") if any. Thus the length of an empty document is zero.

 @return The number of characters in the document */

 EXPORT_C TInt CTextLayout::DocumentLength() const

 	{

 	return iSource->DocumentLength();

 	}

 /** Sets aDocPos to the paragraph start and returns the amount by which aDocPos

 has changed, as a non-negative number.

 @param aDocPos A document position. On return, contains the document position

 of the first character in the paragraph.

 @return The number of characters skipped in moving to the new document

 position. */

 EXPORT_C TInt CTextLayout::ToParagraphStart(TInt& aDocPos) const

 	{

 	TInt old_pos = aDocPos;

 	aDocPos = iSource->ParagraphStart(aDocPos);

 	return old_pos - aDocPos;

 	}

 /** Returns the height in pixels of any formatted text above the visible

 region.

 @return The height in pixels of any formatted text above the visible region. */

 EXPORT_C TInt CTextLayout::PixelsAboveBand() const

 	{

 	return iBandTop;

 	}

 /** Returns the y coordinate of the bottom of the last formatted line, relative

 to the top of the visible region.

 @return The y coordinate of the bottom of the last formatted line. */

 EXPORT_C TInt CTextLayout::YBottomLastFormattedLine() const

 	{

     return Max(0, iText->LayoutHeight() - iBandTop );

 	}

 /** Returns the height in pixels of the formatted text.

 @return The height in pixels of all the formatted text. */

 EXPORT_C TInt CTextLayout::FormattedHeightInPixels() const

 	{

 	return iText->LayoutHeight();

 	}

 /** Returns the number of fully or partially visible characters in the visible

 band.

 @param aDocPos On return, contains the document position of the first fully or

 partially visible character in the band.

 @return The total number of characters in the band. */

 EXPORT_C TInt CTextLayout::PosRangeInBand(TInt& aDocPos) const

 	{

 	TTmLineInfo info;

 	if (!iText->YPosToLine(iBandTop,info))

 		{

 		aDocPos = 0;

 		return 0;

 		}

 	aDocPos = info.iStart;

 	int end = iSource->DocumentLength();

 	//INC085809 - less 1 pixel. Rect edge is actually outside bounds

 	if (iText->YPosToLine(iBandTop + VisibleHeightInPixels() - 1,info))

 		end = info.iEnd;

 	return end - aDocPos;

 	}

 /** Tests whether the document position aDocPos is fully or partially visible.

 If it is, puts the y coordinate of the left-hand end of the baseline of the

 line containing aDocPos into aXyPos.

 @param aDocPos The document position of interest.

 @param aXyPos On return, contains the y coordinate of the left-hand end of the

 baseline of the line containing aDocPos.

 @return ETrue if the position is visible. EFalse if the position is not visible.

 */

 EXPORT_C TBool CTextLayout::PosInBand(TInt aDocPos,TPoint& aXyPos) const

 	{

 	TTmLineInfo info;

 	TTmDocPos pos(aDocPos, ETrue);

 	TBool result = PosInBand(pos,&info);

 	aXyPos.iX = 0;

 	aXyPos.iY = info.iBaseline;

 	return result;

 	}

 /** Tests whether the document position aDocPos is fully or partially visible.

 If it is, puts the y coordinate of the left-hand end of the baseline of the

 line containing aDocPos into aXyPos.

 @param aDocPos The document position of interest.

 @param aXyPos On return, contains the y coordinate of the left-hand end of the

 baseline of the line containing aDocPos.

 @return ETrue if the position is visible. EFalse if the position is not visible.

 */

 EXPORT_C TBool CTextLayout::PosInBand(TTmDocPos aDocPos,TPoint& aXyPos) const

 	{

 	TTmLineInfo info;

 	TBool result = PosInBand(aDocPos,&info);

 	aXyPos.iX = 0;

 	aXyPos.iY = info.iBaseline;

 	return result;

 	}

 /** Tests whether the document position aDocPos is fully or partially visible.

 If it is, puts the baseline of the line containing aDocPos into aLineInfo.

 @param aDocPos The document position of interest.

 @param aLineInfo On return, contains the baseline of the line containing

 aDocPos.

 @return ETrue if the document position aDocPos is fully or partially visible. If

 so, and if aLineInfo is non-NULL, puts information about the line in aLineInfo.

 Otherwise, EFalse */

 EXPORT_C TBool CTextLayout::PosInBand(const TTmDocPos& aDocPos,TTmLineInfo* aLineInfo) const

 	{

 	TTmLineInfo dummy;

 	TTmLineInfo* info_ptr = aLineInfo ? aLineInfo : &dummy;

 	TTagmaForwarder forwarder(*this);

 	if (!forwarder.DocPosToLine(aDocPos,*info_ptr))

 		return FALSE;

 	return info_ptr->iOuterRect.iBr.iY > 0 && info_ptr->iOuterRect.iTl.iY < VisibleHeightInPixels();

 	}

 /** Tests whether the character aDocPos is formatted.

 Note:

 If a section of text contains characters p to q, it contains document positions

 p to q + 1; but this function returns ETrue for positions p to q only, so it

 refers to characters, not positions. However, it will return ETrue for q if q is

 the end of the document.

 @param aDocPos The document position of interest.

 @return ETrue if the character at the document position specified is formatted.

 EFalse if not. */

 EXPORT_C TBool CTextLayout::PosIsFormatted(TInt aDocPos) const

 	{

 	if (aDocPos < iText->StartChar())

 		return FALSE;

 	if (aDocPos >= iText->StartChar() + FormattedLength())

 		return FALSE;

 	return TRUE;

 	}

 /** Gets the document position of the first character in the specified line,

 counting the first line as line one (not zero) in the band. If the line is

 after the band, returns the last character position of the band. If there is no

 formatted text, returns CTextLayout::EFNoCurrentFormat.

 @param aLineNo Line number in formatted text, counting the first line as line

 one.

 @return The document position of the first character on the line. */

 EXPORT_C TInt CTextLayout::FirstCharOnLine(TInt aLineNo) const

 	{

 	if (aLineNo <= 0)

 	    {

 	    OstTrace0( TRACE_DUMP, CTEXTLAYOUT_FIRSTCHARONLINE, "EInvalidLineNumber" );

 	    }

 	__ASSERT_DEBUG(aLineNo > 0,Panic(EInvalidLineNumber));

 	if (iText->StartChar() == iText->EndChar())

 		return EFNoCurrentFormat;

 	aLineNo--;

 	TTmLineInfo info;

 	if (!iText->LineNumberToLine(aLineNo,info))

 		return Min(iText->EndChar(),iSource->DocumentLength());

 	return info.iStart;

 	}

 /** Returns the number of formatted characters. This will be one more than

 expected if the formatted text runs to the end of the document, because it will

 include the end-of-text character.

 @return The number of formatted characters in the document. */

 EXPORT_C TInt CTextLayout::FormattedLength() const

 	{

 	return iText->EndChar() - iText->StartChar();

 	}

 /** Returns the document position of the first formatted character.

 @return The document position of the first formatted character. */

 EXPORT_C TInt CTextLayout::FirstFormattedPos() const

 	{

 	return iText->StartChar();

 	}

 /** Gets the number of formatted lines.

 @return The number of formatted lines in the document. */

 EXPORT_C TInt CTextLayout::NumFormattedLines() const

 	{

 	return iText->Lines();

 	}

 /** Returns the line number, counting from 0, of the first fully visible line.

 @return The line number of the first fully visible line. */

 EXPORT_C TInt CTextLayout::FirstLineInBand() const

 	{

 	TTmLineInfo info;

 	if (!iText->YPosToLine(iBandTop,info))

 		return 0;

 	int line = info.iLineNumber;

 	if (info.iOuterRect.iTl.iY < iBandTop)

 		line++;

 	return line;

 	}

 /** Gets the rectangle enclosing the formatted line that contains or is closest

 to y coordinate aYPos. If aYPos is above the first formatted line, the

 rectangle returned is that of the first formatted line. If aYPos is below the

 last formatted line the rectangle returned is that of the last formatted line.

 If there is no formatted text, returns CTextLayout::EFNoCurrentFormat.

 @param aYPos The y coordinate of the line of interest.

 @param aLine On return, contains the rectangle which encloses the line at

 aYPos.

 @return The line width in pixels. */

 EXPORT_C TInt CTextLayout::GetLineRect(TInt aYPos,TRect& aRect) const

 	{

 	int y = iBandTop + aYPos;

 	// Snap to formatted area.

 	if (y >= iText->LayoutHeight())

 		y = iText->LayoutHeight() - 1;

 	if (y < 0)

 		y = 0;

 	TTmLineInfo info;

 	TBool found = iText->YPosToLine(y,info);

 	if (!found)

 		{

 		aRect.SetSize(TSize(0,0));

 		return EFNoCurrentFormat;

 		}

 	aRect = info.iOuterRect;

 	aRect.iTl.iX = info.iInnerRect.iTl.iX;

 	aRect.iBr.iX = info.iInnerRect.iBr.iX;

 	aRect.Move(0,-iBandTop);

 	return aRect.Width();

 	}

 /** Returns the height of the paragraph containing aDocPos. If the paragraph is

 not formatted, returns zero. If the paragraph is partially formatted, returns

 the height of the formatted part.

 @param aDocPos A document position within the paragraph of interest.

 @return The height in pixels of the paragraph. Zero if the paragraph is not

 formatted. */

 EXPORT_C TInt CTextLayout::ParagraphHeight(TInt aDocPos) const

 	{

 	TRect r;

 	GetParagraphRect(TTmDocPos(aDocPos, ETrue), r);

 	return r.Height();

 	}

 /** Returns the rectangle enclosing the paragraph containing aDocPos. If the

 paragraph is not formatted, returns an empty rectangle. If the paragraph is

 partially formatted, returns the rectangle enclosing the formatted part.

 @param aDocPos A document position within the paragraph.

 @return The rectangle which encloses the paragraph containing aDocPos. */

 EXPORT_C TRect CTextLayout::ParagraphRectL(TInt aDocPos) const

 	{	

 	TRect r;

 	GetParagraphRect(TTmDocPos(aDocPos, ETrue), r);

 	return r;

 	}

 /** Returns the left and right extremes, in layout coordinates, of the

 formatted text.

 @param aLeftX On return, contains the x coordinate of the leftmost point of the

 formatted text.

 @param aRightX On return, contains the x coordinate of the rightmost point of

 the formatted text.

 @param aOnlyVisibleLines If ETrue, only scans partially or fully visible lines.

 If EFalse, scans all the formatted text.

 @param aIgnoreWrapCharacters If ETrue, does not include wrap characters in the

 measurement (paragraph delimiters, forced line breaks, etc.). If EFalse,

 includes them.

 @return EFalse if there is no formatted text, otherwise ETrue. */

 EXPORT_C TBool CTextLayout::CalculateHorizontalExtremesL(TInt& aLeftX,TInt& aRightX,

 														 TBool aOnlyVisibleLines,

 														 TBool /*aIgnoreWrapCharacters*/) const

 	{

 	return CalculateHorizontalExtremes(aLeftX,aRightX,aOnlyVisibleLines);

 	//+ implement aIgnoreWrapCharacters? not until clearly specified

 	}

 TBool CTextLayout::CalculateHorizontalExtremes(TInt& aLeftX,TInt& aRightX,

 											   TBool aOnlyVisibleLines) const

 	{

 	int top = 0;

 	int bottom = KMaxTInt;

 	if (aOnlyVisibleLines)

 		{

 		top = iBandTop;

 		bottom = iBandTop + VisibleHeightInPixels();

 		}

 	iText->HorizontalExtremes(aLeftX, aRightX, top, bottom);

 	if (0 < aLeftX)

 		aLeftX = 0;

 	if (aRightX < iSource->iWidth)

 		aRightX = iSource->iWidth;

 	return iText->StartChar() < iText->EndChar();

 	}

 TInt CTextLayout::WrapWidth() const

 	{

 	return iSource->iWidth;

 	}

 TBool CTextLayout::GetCursor(const TTmDocPos& aDocPos,TTmCursorPlacement aPlacement,

 							 TRect& aLineRect,TPoint& aOrigin,TInt& aWidth,TInt& aAscent,TInt& aDescent) const

 	{

 	TTmLineInfo info;

 	TBool result = iText->GetCursor(aDocPos,aPlacement,info,aOrigin,aWidth,aAscent,aDescent);

 	if (result)

 		{

 		aOrigin.iY -= iBandTop;

 		aLineRect = info.iOuterRect;

 		aLineRect.iTl.iX = info.iInnerRect.iTl.iX;

 		aLineRect.iBr.iX = info.iInnerRect.iBr.iX;

 		aLineRect.Move(0,-iBandTop);

 		}

 	return result;

 	}

 /** Gets the height (ascent + descent) and ascent of the font of the character

 at aDocPos, as created using the graphics device map used for drawing (the

 "image device") and returns them in aHeight and aAscent, after increasing

 aHeight by the font height increase factor (see SetFontHeightIncreaseFactor()).

 @param aDocPos A document position.

 @param aHeight On return contains the height in pixels of the character at

 aDocPos.

 @param aAscent On return, contains the ascent in pixels of the character at

 aDocPos. */

 EXPORT_C void CTextLayout::GetCharacterHeightAndAscentL(TInt aDocPos,TInt& aHeight,TInt& aAscent) const

 	{

 	TPtrC text;

 	TTmCharFormat format;

 	iSource->GetText(aDocPos,text,format);

 	TFontSpec fs;

 	format.iFontSpec.GetTFontSpec(fs);

 	GetFontHeightAndAscentL(fs,aHeight,aAscent);

 	}

 /** Gets the height (ascent + descent) and ascent of the font specified by

 aFontSpec, as created using the graphics device map used for drawing (the

 "image device") and puts them into aHeight and aAscent, after increasing

 aHeight by the font height increase factor (see SetFontHeightIncreaseFactor()).

 @param aFontSpec Font specification.

 @param aHeight On return, contains the height in pixels of the font.

 @param aAscent On return, contains the ascent in pixels of the font. */

 EXPORT_C void CTextLayout::GetFontHeightAndAscentL(const TFontSpec& aFontSpec,TInt& aHeight,TInt& aAscent) const

 	{

 	CFont* font;

 	MGraphicsDeviceMap& device = iSource->InterpretDevice();

 	User::LeaveIfError(device.GetNearestFontInTwips(font,aFontSpec));

 	aHeight = font->HeightInPixels();

 	int increase = (iSource->iFontHeightIncreaseFactor * aHeight) / 100;

 	aHeight += increase;

 	aAscent = font->AscentInPixels() + increase;

 	device.ReleaseFont(font);

 	}

 /** Returns the index of the nearest character in the document to the window 

 coordinates specified. Sets aPos to the actual position of the intersection 

 of the line's baseline with the character's edge. If aPos is before the start

 of the formatted area, returns the first formatted character; if it is after 

 the end of the formatted area, returns the position after the last formatted 

 character, or the end of the document, whichever is less.

 This function is deprecated in v7.0s. Use the more powerful FindXYPos() instead.

 @param aPos Contains coordinates to convert to a document position. On return,

 contains the exact coordinates of the intersection of the line's baseline with

 the character edge at the document position.

 @param aFlags Three possible values: 0 is the default, and performs the task at

 full accuracy (the function returns the document position of the character edge

 nearest to the coordinates). CLayoutData::EFWholeLinesOnly examines lines only

 and returns the position at the right end of the line if aPos.iX > 0, otherwise

 the position at the left end.

 @return The document position of the nearest character to the coordinates, or

 of the start or end of the line, depending on the value of aFlags. */

 EXPORT_C TInt CTextLayout::XyPosToDocPosL(TPoint &aXyPos,TUint) const

 	{

 	if (aXyPos.iY < -iBandTop)

 		return iText->StartChar();

 	else if (aXyPos.iY >= iText->LayoutHeight() - iBandTop)

 		return Min(iText->EndChar(),iSource->DocumentLength());

 	TTmPosInfo2 pos_info;

 	TTmLineInfo lineInfo;

 	FindXyPos(aXyPos,pos_info, &lineInfo);

 	aXyPos = pos_info.iEdge;

 	TInt r = pos_info.iDocPos.iPos;

 	if (!pos_info.iDocPos.iLeadingEdge && lineInfo.iStart != r)

 		{

 		r -= 1;

 		//	surrogate support

 		if ( r > 0 )

 			{

 			TPtrC text;

 			TTmCharFormat format;

 			iSource->GetText( r - 1, text, format );

 			if ( text.Length() > 1 )

 				{

 				TUint highSurrogate = text[0];

 				TUint lowSurrogate = text[1];

 				if ( TChar::IsHighSurrogate( highSurrogate ) &&

 				        TChar::IsLowSurrogate( lowSurrogate ) )

 					--r;

 				}

 			}

 		}

 	return r;

 	}

 /** Finds the document position nearest to aXyPos. If aXyPos is in the

 formatted text returns ETrue, otherwise returns EFalse. If ETrue is returned,

 places information about the document position in aPosInfo and information

 about the line containing the document position in aLineInfo if it is non-NULL.

 @param aXyPos Contains coordinates to convert to a document position.

 @param aPosInfo Buffer to store information about the document position if the

 specified coordinates are located in the formatted text.

 @param aLineInfo Buffer to store information about the line if the specified

 coordinates are located in the formatted text.

 @return ETrue if aXyPos is a formatted position, otherwise EFalse. */

 EXPORT_C TBool CTextLayout::FindXyPos(const TPoint& aXyPos,TTmPosInfo2& aPosInfo,TTmLineInfo* aLineInfo) const

 	{

 	TTagmaForwarder forwarder(*this);

 	TTmLineInfo line_info;

 	TBool result = forwarder.FindXyPos(aXyPos,aPosInfo,line_info);

 	if (aLineInfo && result)

 		*aLineInfo = line_info;

 	return result;

 	}

 /** Returns the x-y coordinates of the document position aDocPos in aPos. The

 return value is ETrue if the position is formatted, or EFalse if it is not, in

 which case aPos is undefined.

 Deprecated - use the more powerful FindDocPos() instead

 @param aDocPos The document position.

 @param aPos On return, contains the x-y coordinates of aDocPos.

 @param aFlags Two possible values: 0 is the default, and performs the task at

 full accuracy, and CLayoutData::EFWholeLinesOnly, which examines lines only and

 sets aXyPos.iY only, and cannot leave.

 @return ETrue if the document position is formatted, EFalse if not. */

 EXPORT_C TBool CTextLayout::DocPosToXyPosL(TInt aDocPos,TPoint& aXyPos,TUint /*aFlags*/) const

 	{

 	TTmDocPos doc_pos(aDocPos, ETrue);

 	TTmPosInfo2 pos_info;

 	TBool result = FindDocPos(doc_pos,pos_info);

 	aXyPos = pos_info.iEdge;

 	return result;

 	}

 /** Finds the x-y position of the document position aDocPos.

 If ETrue is returned, places information about the document position in aPosInfo

 and information about the line containing the document position in aLineInfo if

 it is non-NULL.

 @param aDocPos Contains the document position to check.

 @param aPosInfo On return, stores information about the document position if

 the position is formatted.

 @param aLineInfo Buffer to store the line information if the document position

 is formatted.

 @return ETrue if aDocPos is in the formatted text, otherwise EFalse. */

 EXPORT_C TBool CTextLayout::FindDocPos(const TTmDocPosSpec& aDocPos,TTmPosInfo2& aPosInfo,TTmLineInfo* aLineInfo) const

 	{

 	TTagmaForwarder forwarder(*this);

 	TTmLineInfo line_info;

 	TBool result = forwarder.FindDocPos(aDocPos,aPosInfo,line_info);

 	if (aLineInfo && result)

 		*aLineInfo = line_info;

 	return result;

 	}

 /** Finds the next cursor position to aDocPos in the visually ordered line.

 @param aDocPos Contains the document position to check.

 @param aPosInfo On return, stores information about the document position of

 the next cursor position, if ETrue is returned.

 @param aToLeft ETrue if the position to the left is to be found, or EFalse if

 the position to the right is to be found.

 @return EFalse if there is no formatting, or the position is at the end of the

 line already. ETrue otherwise. */

 EXPORT_C TBool CTextLayout::GetNextVisualCursorPos(

 	const TTmDocPosSpec& aDocPos, TTmPosInfo2& aPosInfo, TBool aToLeft) const

 	{

 	TTagmaForwarder forwarder(*this);

 	return forwarder.GetNextVisualCursorPos(aDocPos, aPosInfo, aToLeft);

 	}

 /** Gets a rectangle enclosing two formatted document positions on the same

 line. If the second position is less than the first, or on a different line, it

 is taken to indicate the end of the line. This function panics if either

 position is unformatted.

 Note:

 CTextLayout must have been set with a valid wrap width and band height before

 calling this function, otherwise no formatting will take place and the function 

 will panic.  Wrap width and band height values must be > 0 to be valid.

 @param aDocPos1 The first document position on the line.

 @param aDocPos2 The second document position on the line.

 @return The minimal rectangle, which bounds both positions.

 @see SetBandHeight

 @see SetWrapWidth */

 EXPORT_C TRect CTextLayout::GetLineRectL(TInt aDocPos1,TInt aDocPos2) const

 	{

 	TRect rect;

 	TPoint point;

 	TInt xCoords[4];

 	if (iText->LayoutHeight() == 0)

 		return TRect(0,0,0,0);

 	if (!PosIsFormatted(aDocPos1))

 	    {

 	    OstTrace0( TRACE_FATAL, CTEXTLAYOUT_GETLINERECTL, "ECharacterNotFormatted" );

 	    }

 	__ASSERT_ALWAYS(PosIsFormatted(aDocPos1),Panic(ECharacterNotFormatted));

 	if (!PosIsFormatted(aDocPos2))

 	    {

 	    OstTrace0( TRACE_DUMP, DUP1_CTEXTLAYOUT_GETLINERECTL, "ECharacterNotFormatted" );

 	    }

 	__ASSERT_DEBUG(PosIsFormatted(aDocPos2),Panic(ECharacterNotFormatted));

 	TTmDocPosSpec docSpec(aDocPos1, TTmDocPosSpec::ELeading);

 	TTmPosInfo2 pos_info;

 	// Finding the leading edge of aDocPos1

 	FindDocPos(docSpec,pos_info);

 	point = pos_info.iEdge;

 	xCoords[0] = point.iX;

 	// Getthe Line rectangle

 	GetLineRect(point.iY,rect);

 	if (rect.iTl.iY > point.iY || rect.iBr.iY < point.iY)

 	    {

 	    OstTrace0( TRACE_DUMP, DUP2_CTEXTLAYOUT_GETLINERECTL, "EPixelNotInFormattedLine" );

 	    }

 	__ASSERT_DEBUG(rect.iTl.iY <= point.iY && rect.iBr.iY >= point.iY,Panic(EPixelNotInFormattedLine));

 	//	Finding the leading edge of aDocPos2

 	docSpec.iPos = aDocPos2;

 	TBool isformatted = FindDocPos(docSpec, pos_info);

 	point = pos_info.iEdge;

 	// Checks if the aDocPos2 is contained in the same line of the aDocPos1

 	// Can't use TRect::Contains() here, because TRect::Contains() considers a point located on the right  

 	// hand side or bottom as outside the rectangle, which will has problem when work with RTL text that 

 	// is at the right hand end of a line.

 	TBool isContained = (point.iX>=rect.iTl.iX && point.iX<=rect.iBr.iX 

 				&& point.iY>=rect.iTl.iY && point.iY<=rect.iBr.iY);

 	RTmParFormat parFormat;

 	iSource->GetParagraphFormatL(aDocPos1, parFormat);

 	//	The special cases (as indicated in the description):

 	//	When the aDocPos2 is less than the aDocPos1, or not formatted, or on a different line from which the  

 	//	aDocPos1 is in, then the function will return the rectangle starting from docPos1's leading edge and

 	//	ending at the end of the line (which is determined by paragraph directionality).

 	if (aDocPos2 < aDocPos1 || !isformatted || !isContained)

 		{

 		if (parFormat.RightToLeft())

 			rect.iBr.iX = xCoords[0];

 		else

 			rect.iTl.iX = xCoords[0];

 		parFormat.Close();

 		return rect;

 		}

 	xCoords[1] = point.iX;

 	//	Finding the Trailing edge of (aDocPos1 + 1)

 	docSpec.iType = TTmDocPosSpec::ETrailing;

 	docSpec.iPos = aDocPos1 + 1;

 	FindDocPos(docSpec, pos_info);

 	xCoords[2] = pos_info.iEdge.iX;

 	//	Finding the Trailing edge of (aDocPos2 + 1)

 	docSpec.iPos = aDocPos2 + 1;

 	FindDocPos(docSpec, pos_info);

 	xCoords[3] = pos_info.iEdge.iX;

 	rect.iBr.iX = xCoords[0];

 	rect.iTl.iX = xCoords[0];

 	// The returned rectangle is generated by (when is not a special case)

 	// 1) Find the Line rectangle

 	// 2) Find the:

 	//		- leading edge of docPos1 

     //		- leading edge of docPos2 

     //		- trailing edge of docPos1+1 

     //		- trailing edge of docPos2+1

 	// 3) Cut the line rectangle at the smallest edge and the largest edge among 

 	//	  the four edges found in step 2.

 	for (TInt i = 1; i<4; i++ )

 		{

 		if (rect.iBr.iX < xCoords[i])

 			rect.iBr.iX = xCoords[i];

 		if (rect.iTl.iX > xCoords[i])

 			rect.iTl.iX = xCoords[i];

 		}

 	parFormat.Close();

 	return rect;

 	}

 /** Gets the bounding rectangle of the picture, if any, located at the document

 position or coordinates specified, and returns it in aPictureRect.

 If aCanScaleOrCrop is non-null, sets aCanScaleOrCrop to indicate 

 whether the picture can be scaled or cropped. 

 Returns ETrue if the operation was successful. Returns EFalse otherwise;

 that is, if there is no picture at the position, or if the position is unformatted.

 @param aDocPos The document position of interest.

 @param aXyPos The layout coordinates of interest.

 @param aPictureRect On return, contains the rectangle which encloses the

 picture located at the position specified.

 @param aCanScaleOrCrop If non-NULL and the function returns ETrue, on return,

 indicates whether the picture can be scaled or cropped. By default, NULL.

 @return ETrue if the operation was successful, (i.e. there is a

 picture character at the position, it has been loaded into

 memory, and the position is formatted). EFalse if any of these

 conditions are not met. */

 EXPORT_C TBool CTextLayout::PictureRectangleL(TInt aDocPos,TRect& aPictureRect,TBool* aCanScaleOrCrop) const

 	{

 	if (aDocPos < iText->StartChar() || aDocPos >= iText->EndChar() - 1)

 		return FALSE;

 	aPictureRect.SetRect(0,0,0,0);

 	TSize size;

 	if (iSource->GetPictureSizeInTwipsL(aDocPos,size) != KErrNone)

 		return FALSE;

 	TRect rect;

 	TTmDocPos pos(aDocPos, ETrue);

 	TTmPosInfo2 pos_info;

 	TTmLineInfo info;

 	TInt subscript;

 	if (!iText->FindDocPos(pos,pos_info,info,subscript))

 		return FALSE;

 	MGraphicsDeviceMap& device = iSource->InterpretDevice();

 	size.iWidth = device.HorizontalTwipsToPixels(size.iWidth);

 	size.iHeight = device.VerticalTwipsToPixels(size.iHeight);

 	rect.iBr.iY = pos_info.iEdge.iY - iBandTop + subscript;

 	rect.iTl.iY = rect.iBr.iY - size.iHeight;

 	if (pos_info.iRightToLeft)

 		{

 		rect.iBr.iX = pos_info.iEdge.iX;

 		rect.iTl.iX = rect.iBr.iX - size.iWidth;

 		}

 	else

 		{

 		rect.iTl.iX = pos_info.iEdge.iX;

 		rect.iBr.iX = rect.iTl.iX + size.iWidth;

 		}

 /*	rect.iTl = pos_info.iEdge;

 	rect.Move(0,-iBandTop);

 	rect.iTl.iY -= size.iHeight;

 	rect.iBr = rect.iTl + size;*/

 	CPicture* picture = iSource->PictureL(aDocPos);

 	if (!picture)

 		return FALSE;

 	if (aCanScaleOrCrop)

 		*aCanScaleOrCrop = picture->Capability().iScalingType != TPictureCapability::ENotScaleable ||

 						   picture->Capability().iIsCroppable;

 	aPictureRect = rect;

 	return TRUE;

 	}

 /** Finds if there is a picture at the position under the point aXyPos.

 If there is, returns the document position of it, sets the rectangle

 occupied in aPictureRect, and whether the picture allows scaling

 in aCanScaleOrCrop, if non-null. Note that aXyPos may be outside

 the picture found.

 @return  The document position of the picture found, or KErrNotFound if there 

 is none. */

 TInt CTextLayout::PictureRectangleAndPosL(const TPoint& aXyPos, TRect& aPictureRect,

 	TBool* aCanScaleOrCrop) const

 	{

 	TTmPosInfo2 posInfo;

 	if (!FindXyPos(aXyPos, posInfo))

 		return KErrNotFound;

 	TInt doc_pos = posInfo.iDocPos.iPos - (posInfo.iDocPos.iLeadingEdge? 0 : 1);

 	if (PictureRectangleL(doc_pos, aPictureRect, aCanScaleOrCrop))

 		return doc_pos;

 	return KErrNotFound;

 	}

 /** Gets the bounding rectangle of the picture (if any) at aXyPos and puts it

 in aPictureRect. If aCanScaleOrCrop is non-null sets *aCanScaleOrCrop to

 indicate whether the picture can be scaled or cropped. Note that aXyPos

 may be outside aPictureRect on a successful return, if the picture does

 not occupy the whole of the section of the line it is in.

 @return ETrue if the position is formatted and there is a picture there. */	

 EXPORT_C TBool CTextLayout::PictureRectangleL(const TPoint& aXyPos,

 	TRect& aPictureRect, TBool* aCanScaleOrCrop) const

 	{

 	return 0 <= PictureRectangleAndPosL(aXyPos, aPictureRect, aCanScaleOrCrop)?

 		ETrue : EFalse;

 	}

 /** Gets the first document position in a line that starts at or below the top

 of the visible area. If there is no such line, returns the position after the

 last formatted character.

 @return The document position of the first character in a line within the

 visible area. */

 EXPORT_C TInt CTextLayout::FirstDocPosFullyInBand() const

 	{

 	TTmLineInfo info;

 	if (!iText->YPosToLine(iBandTop,info))

 		return iText->EndChar();

 	if (info.iOuterRect.iTl.iY < iBandTop)

 		return info.iEnd;

 	else

 		return info.iStart;

 	}

 /** This interface is deprecated, and is made available in version 7.0s solely

 to provide binary compatibility with Symbian OS v6.1. Developers are strongly

 advised not to make use of this API in new applications. In particular, use the

 other overload of this function if you need to distinguish between leading and

 trailing edge positions.

 Do not use if a CTextView object owns this CTextLayout object.

 @param aDocPos A valid document position.

 @param aYPos The y coordinate at which to display the character at aDocPos. On

 return, contains the actual vertical position of the specified part of the

 line.

 @param aYPosQualifier Controls which part of the line is set to appear at

 aYPos.

 @param aDiscardFormat If ETrue (EFViewDiscardAllFormat), the text is reformatted

 to include aDocPos, otherwise text is formatted only as necessary when bringing

 new lines into the visible area.

 @return The number of pixels the text was scrolled, may be positive or

 negative. A value of CTextLayout::EFScrollRedrawWholeScreen indicates that the

 entire visible area, at least, was scrolled, and so there is no point in

 blitting text; a full redraw is needed. */

 EXPORT_C TInt CTextLayout::SetViewL(TInt aDocPos,TInt& aYPos,TViewYPosQualifier aYPosQualifier,TDiscard aDiscardFormat)

 	{

 	TTmDocPos pos(aDocPos, ETrue);

 	return SetViewL(pos,aYPos,aYPosQualifier,aDiscardFormat);

 	}

 /** Changes the top of the visible area so that the line containing aDocPos is

 vertically positioned at aYPos. Which part of the line is set to appear at

 aYPos (top, baseline, or bottom) is controlled by the TViewYPosQualifier

 argument, which also specifies whether the visible area is to be filled and

 whether the line should be made fully visible if possible.

 Do not use if a CTextView object owns this CTextLayout object.

 @param aDocPos A valid document position.

 @param aYPos The y coordinate at which to display the character at aDocPos. On

 return, contains the actual vertical position of the specified part of the

 line.

 @param aYPosQualifier Controls which part of the line is set to appear at

 aYPos.

 @param aDiscardFormat If ETrue (EFViewDiscardAllFormat), the text is reformatted

 to include aDocPos, otherwise text is formatted only as necessary when bringing

 new lines into the visible area.

 @return The number of pixels the text was scrolled, may be positive or

 negative. A value of CTextLayout::EFScrollRedrawWholeScreen indicates that the

 entire visible area, at least, was scrolled, and so there is no point in

 blitting text; a full redraw is needed. */

 EXPORT_C TInt CTextLayout::SetViewL(const TTmDocPos& aDocPos, TInt& aYPos,

 	TViewYPosQualifier aYPosQualifier, TDiscard aDiscardFormat)

 	{

 	if (aDocPos.iPos < 0 || aDocPos.iPos > iSource->DocumentLength())

 		Panic(EInvalidDocPos);

 	/*

 	If the format is to be discarded, or no text has yet been formatted, or if the document position

 	to be viewed is not formatted, format the band.

 	*/

 	TTmLineInfo info;

 	TBool all_formatted = FALSE;

 	TBool pos_is_formatted = iText->DocPosToLine(aDocPos,info);

 	if (!pos_is_formatted ||

 		aDiscardFormat == EFViewDiscardAllFormat ||

 		(iText->StartChar() == iText->EndChar() && iSource->DocumentLength() > 0))

 		{

 		FormatBandL(aDocPos.iPos,aDocPos.iPos);

 		all_formatted = TRUE;

 		pos_is_formatted = iText->DocPosToLine(aDocPos,info);

 		}

 	// Find out where the top of the line is.

 	if (!pos_is_formatted)

 		return 0;

 	int line_top_y = info.iOuterRect.iTl.iY - iBandTop;

 	// Determine the desired position of the top of the line.

 	int offset = 0;

 	if (aYPosQualifier.iHotSpot == TViewYPosQualifier::EFViewBaseLine)

 		offset = info.iBaseline - info.iOuterRect.iTl.iY;

 	else if (aYPosQualifier.iHotSpot == TViewYPosQualifier::EFViewBottomOfLine)

 		offset = info.iOuterRect.iBr.iY - info.iOuterRect.iTl.iY;

 	int desired_line_top_y = aYPos - offset;

 	// Adjust aYPos so that the line is fully visible if desired.

 	if (aYPosQualifier.iFullyVisible == TViewYPosQualifier::EFViewForceLineFullyVisible)

 		{

 		TInt screenHeight = VisibleHeightInPixels();

 		TInt lineHeight = info.iOuterRect.Height();

 		TInt lineAscent = info.iBaseline - info.iOuterRect.iTl.iY;

 		// If the top of the line is off the top of the screen, and the

 		// baseline and the top can both fit, make the top of the line flush

 		// with the top of the screen.

 		if (lineAscent <= screenHeight

 			&& desired_line_top_y < 0)

 			desired_line_top_y = 0;

 		// If the whole line can fit and the bottom if off the bottom of the

 		// screen, make the bottom flush with the bottom of the screen.

 		if (lineHeight <= screenHeight

 			&& screenHeight < desired_line_top_y + lineHeight)

 			desired_line_top_y = screenHeight - lineHeight;

 		// If the ascent will not fit, or the baseline is off the bottom of

 		// the screen, move the baseline flush with the bottom of the screen

 		if (screenHeight < lineAscent

 			|| screenHeight < desired_line_top_y + lineAscent)

 			desired_line_top_y = screenHeight - lineAscent;

 		}

 	// Scroll the document position to the desired vertical coordinate and update aYPos.

 	TInt dy = desired_line_top_y - line_top_y;

 	if (dy)

 		{

 		dy = ScrollL(dy,aYPosQualifier.iFillScreen ? EFDisallowScrollingBlankSpace : EFAllowScrollingBlankSpace);

 		line_top_y += dy;

 		aYPos = line_top_y + offset;

 		// Ensure that aYPos is in the line.

 		if (aYPosQualifier.iHotSpot == TViewYPosQualifier::EFViewBottomOfLine)

 			aYPos--;

 		}

 	return all_formatted ? EFScrollRedrawWholeScreen : dy;

 	}

 /** Formats enough text to fill the visible band.

 Note: Do not use if a CTextView object owns this CTextLayout object. */

 EXPORT_C void CTextLayout::FormatBandL()

 	{

 	FormatBandL(0,0);

 	}

 /**

 Format enough text to fill the visible band and include both aStartDocPos and

 aEndDocPos. Start at the start of the document if formatting everything, or at

 the start of the paragraph containing aStartDocPos if formatting the visible

 band only.

 */

 void CTextLayout::FormatBandL(TInt aStartDocPos,TInt aEndDocPos)

 	{

 	TTmFormatParam param;

 	InitFormatParam(param);

 	if (iBandHeight != CLayoutData::EFHeightForFormattingAllText)

 		param.iStartChar = iSource->ParagraphStart(aStartDocPos);

 	if (param.iWrapWidth < 1 || param.iMaxHeight < 1)

 		{

 		// Do just a little formatting if the values are illegal.

 		// This is to prevent the AddParL running with no

 		// height limit, taking up huge amounts of time, and

 		// having to return with 0 lines formatted, which

 		// confuses CEikEdwin.

 		param.iMaxHeight = 1;

 		param.iWrapWidth = 1;

 		iText->SetTextL(*iSource,param);

 		return;

 		}

 	iText->SetTextL(*iSource,param);

 	param.iMaxHeight = KMaxTInt;

 	if(IsFormattingBand() && (iText->EndChar() <= aEndDocPos && iText->EndChar() < iSource->DocumentLength()))

 		{

 		param.iEndChar = Min(aEndDocPos+1,iSource->DocumentLength());

 		iText->ExtendFormattingDownwardsL(param);

 		}

 	else

 		{

 		while (iText->EndChar() <= aEndDocPos && iText->EndChar() < iSource->DocumentLength())

 			{

 			int h,p;

 			AddFormattingAtEndL(param, h, p);

 			}

 		}

 	if (iBandHeight != CLayoutData::EFHeightForFormattingAllText)

 		{

 		int visible_height = VisibleHeightInPixels();

 		while (iText->LayoutHeight() < visible_height)

 			{

 			int h,p;

 			if (!iText->AddParL(param,TRUE,h,p))

 				break;

 			}

 		}

 	iBandTop = 0;

 	}

 /** Makes sure the line that aYPos is in (if it exists) is covered by the

 formatting.

 @param aYPos Y pixel position in window-relative co-ordinates.

 @internalComponent

 */

 EXPORT_C void CTextLayout::ExtendFormattingToCoverYL(TInt aYPos)

 	{

 	TTmFormatParam param;

 	InitFormatParam(param);

 	param.iStartChar = iText->StartChar() - 1;

 	param.iEndChar = iText->EndChar();

 	param.iMaxHeight = KMaxTInt;

 	TInt heightIncrease;

 	TInt p;

 	while (iBandTop < -aYPos && iText->AddParL(param, ETrue, heightIncrease, p))

 		{

 		iBandTop += heightIncrease;

 		param.iStartChar = iText->StartChar() - 1;

 		}

 	TInt heightRemaining = iBandTop + aYPos - iText->LayoutHeight() + 1;

 	if(heightRemaining > 0)

 		{

 		param.iStartChar = iText->EndChar();

 		param.iEndChar = KMaxTInt;

 		param.iMaxHeight = heightRemaining;

 		iText->ExtendFormattingDownwardsL(param);

 		}

 	}

 /** Allows you to increase the formatted text range by specifying a point in the text you

 want to increase the range to. Makes sure the line that aDocPos is in (if it exists) is covered by the

 formatting.

 @param aDocPos Position in the text you wish to extend the formatting to. e.g. passing in 0 will

 increase the formatting range to the very first character entered in the document.

 @pre aDocPos is in the range 0...DocumentLength

 @post aDocPos has been formatted

 */

 EXPORT_C void CTextLayout::ExtendFormattingToCoverPosL(TInt aDocPos)

 	{

 	if (0 > aDocPos || aDocPos > DocumentLength())

 	    {

 	    OstTrace0( TRACE_DUMP, CTEXTLAYOUT_EXTENDFORMATTINGTOCOVERPOSL, "EInvalidDocPos" );

 	    }

 	__ASSERT_DEBUG(0 <= aDocPos && aDocPos <= DocumentLength(),

 			Panic(EInvalidDocPos));

 	TTmFormatParam param;

 	InitFormatParam(param);

 	param.iStartChar = iText->StartChar();

 	param.iEndChar = iText->EndChar();

 	param.iMaxHeight = KMaxTInt;

 	TInt heightIncrease;

 	TInt p;

 	TInt pos = aDocPos;

 	if(pos > 0)     // Avoid going into infinite loop.

 		{

 		pos -= 1;	

 		}						

 	while ((pos < param.iStartChar) && (iText->AddParL(param, ETrue, heightIncrease, p)))

 		{

 		iBandTop += heightIncrease;

 		param.iStartChar = iText->StartChar();

 		}	

 	param.iEndChar = aDocPos + 1;

 	if(iText->EndChar() < param.iEndChar)

 		{

 		iText->ExtendFormattingDownwardsL(param);

 		}

 	if ((aDocPos < iText->StartChar()) || (aDocPos > iText->EndChar()))

 	    {

 	    OstTrace0( TRACE_DUMP, DUP1_CTEXTLAYOUT_EXTENDFORMATTINGTOCOVERPOSL, "ECharacterNotFormatted" );

 	    }

 	__ASSERT_DEBUG((aDocPos >= iText->StartChar()) && (aDocPos <= iText->EndChar()),

 			Panic(ECharacterNotFormatted));

 	}

 /** Sets the formatted text to begin at the start of the paragraph including

 aStartPos and end at aEndPos. Moves the line containing aStartDocPos to the top

 of the visible area.

 Notes:

 This function is not generally useful; it exists for the convenience of the

 printing system.

 Do not use if a CTextView object owns this CTextLayout object.

 @param aStartDocPos A document position within the paragraph from which to

 begin formatting.

 @param aEndDocPos Document position at which to end formatting. */

 EXPORT_C void CTextLayout::FormatCharRangeL(TInt aStartDocPos,TInt aEndDocPos)

 	{

 	FormatCharRangeL(aStartDocPos,aEndDocPos,0);

 	}

 void CTextLayout::FormatCharRangeL(TInt aStartDocPos,TInt aEndDocPos,TInt aPixelOffset)

 	{

 	if (aStartDocPos < 0 && aStartDocPos > DocumentLength())

 	    {

 	    OstTrace0( TRACE_DUMP, CTEXTLAYOUT_FORMATCHARRANGEL, "EInvalidDocPos" );

 	    }

 	__ASSERT_DEBUG(aStartDocPos >= 0 && aStartDocPos <= DocumentLength(),Panic(EInvalidDocPos));

 	if (aEndDocPos < 0 || aEndDocPos > DocumentLength())

 	    {

 	    OstTrace0( TRACE_DUMP, DUP1_CTEXTLAYOUT_FORMATCHARRANGEL, "EInvalidDocPos" );

 	    }

 	__ASSERT_DEBUG(aEndDocPos >= 0 && aEndDocPos <= DocumentLength(),Panic(EInvalidDocPos));

 	if (aStartDocPos > aEndDocPos)

 	    {

 	    OstTrace0( TRACE_DUMP, DUP2_CTEXTLAYOUT_FORMATCHARRANGEL, "ENoCharRangeToFormat" );

 	    }

 	__ASSERT_DEBUG(aStartDocPos <= aEndDocPos,Panic(ENoCharRangeToFormat));

 	TTmFormatParam param;

 	InitFormatParam(param);

 	param.iStartChar = iSource->ParagraphStart(aStartDocPos);

 	param.iEndChar = aEndDocPos;

 	param.iMaxHeight = KMaxTInt;

 	iText->SetTextL(*iSource,param);

 	TTmLineInfo info;

 	TTmDocPos pos(aStartDocPos, ETrue);

 	if (iText->DocPosToLine(pos,info))

 		iBandTop = info.iOuterRect.iTl.iY - aPixelOffset;

 	else

 		iBandTop = 0; //+ raise an exception?

 	}

 /** A special function to support background formatting by the higher level

 CTextView class. It formats the next pending line. The return value is ETrue if

 there is more formatting to do. On entry, aBotPixel contains the y coordinate

 of the bottom of the formatted text; this is updated by the function.

 Notes:

 Not generally useful.

 Do not use if a CTextView object owns this CTextLayout object.

 @param aBotPixel On entry, contains the y coordinate of the bottom of the

 formatted text; this is updated by the function.

 @return ETrue if there is more formatting to do. EFalse if not. */

 EXPORT_C TBool CTextLayout::FormatNextLineL(TInt& aBottomPixel)

 	{

 	if (iUnformattedStart < KMaxTInt)

 		{

 		TTmFormatParamBase param;

 		InitFormatParam(param);

 		param.iMaxHeight = KMaxTInt;

 		TTmReformatParam reformat_param;

 		reformat_param.iStartChar = iUnformattedStart;

 		reformat_param.iMaxExtraLines = KMaxExtraLines;

 		reformat_param.iParInvalid = iParInvalid;

 		TTmReformatResult result;

 		iText->FormatL(param,reformat_param,result);

 		// If there is no formatting to do, indicate that formatting is complete to the end of the paragraph

 		if (result.iUnformattedStart == KMaxTInt)

 			{

 			TTmLineInfo info;

 			TTmDocPos pos(iUnformattedStart, ETrue);

 			TBool isFormatted = iText->DocPosToLine(pos,info);

 			if (!isFormatted)

 			    {

 			    OstTrace0( TRACE_DUMP, CTEXTLAYOUT_FORMATNEXTLINEL, "EPosNotFormatted" );

 			    }

 			__ASSERT_DEBUG(isFormatted, Panic(EPosNotFormatted));

 			isFormatted = iText->ParNumberToLine(info.iParNumber,KMaxTInt,info);

 			if (!isFormatted)

 			    {

 			    OstTrace0( TRACE_DUMP, DUP1_CTEXTLAYOUT_FORMATNEXTLINEL, "EPosNotFormatted" );

 			    }

 			__ASSERT_DEBUG(isFormatted, Panic(EPosNotFormatted));

 			aBottomPixel = info.iOuterRect.iBr.iY - iBandTop;

 			}

 		// Indicate that formatting is complete up to the lower edge of the current line.

 		else

 			aBottomPixel = result.iRedrawRect.iBr.iY - iBandTop;

 		iUnformattedStart = result.iUnformattedStart;

 		}

 	return iUnformattedStart < KMaxTInt;

 	}

 /** Controls the height of a single line, for use by the pagination system

 only. Using the format supplied in aParaFormat, determines the height of the

 line containing aDocPos and returns it in aHeight. Changes aDocPos to the end

 of the line and returns ETrue if that position is not the end of the paragraph.

 Notes:

 Not generally useful; it exists for use by the pagination system only.

 Do not use if a CTextView object owns this CTextLayout object.

 @param aParaFormat Contains paragraph formatting.

 @param aDocPos A document position. On return, contains the document position

 of the end of the line.

 @param aHeight On return, contains the height of the formatted line containing

 aDocPos.

 @param aPageBreak On return, ETrue if the last character on the line is a page

 break. EFalse if not.

 @return ETrue if the line is not the last line in the paragraph. EFalse if it is

 the last line. */

 EXPORT_C TBool CTextLayout::FormatLineL(CParaFormat* /*aParaFormat*/,TInt& aDocPos,

 										TInt& aHeight,TBool& aPageBreak)

 	{

 	// If the line is not formatted, replace the formatted text with the single paragraph containing the line.

 	if (aDocPos < iText->StartChar() || aDocPos >= iText->EndChar())

 		{

 		TTmFormatParam param;

 		InitFormatParam(param);

 		param.iStartChar = iSource->ParagraphStart(aDocPos);

 		param.iEndChar = iSource->ParagraphEnd(aDocPos);

 		param.iMaxHeight = KMaxTInt;

 		iText->SetTextL(*iSource,param);

 		}

 	TTmLineInfo info;

 	TTmDocPos pos(aDocPos, ETrue);

 	if (!iText->DocPosToLine(pos,info))

 		User::Leave(KErrGeneral);

 	aHeight = info.iOuterRect.Height();

 	aDocPos = info.iEnd;

 	TPtrC text;

 	TTmCharFormat format;

 	iSource->GetText(info.iEnd - 1,text,format);

 	aPageBreak = text[0] == CEditableText::EPageBreak;

 	return !(info.iFlags & TTmLineInfo::EParEnd);

 	}

 /** Scrolls the text up or down by aNumParas paragraphs, disallowing blank

 space at the bottom of the visible area if aScrollBlankSpace is

 CTextLayout::EFDisallowScrollingBlankSpace.

 Do not use if a CTextView object owns this CTextLayout object.

 @param aNumParas The number of paragraphs to scroll; may be a positive or

 negative value. On return, contains the number of paragraphs not scrolled; that

 is the difference between the requested number and the number of paragraphs

 actually scrolled.

 @param aScrollBlankSpace Only relevant when scrolling downwards.

 CTextLayout::EFAllowScrollingBlankSpace allows blank space to scroll into the

 visible area. CTextLayout::EFDisallowScrollingBlankSpace prevents blank space

 from scrolling into the visible area.

 @pre aPars must not scroll the display beyond the formatted range. If aPars

 scrolls beyond the formatted range, this method will leave with the error code

 CTextLayout::EPosNotFormatted

 @return The number of pixels actually scrolled. */

 EXPORT_C TInt CTextLayout::ScrollParagraphsL(TInt& aPars,TAllowDisallow aScrollBlankSpace)

 	{

 	TTmFormatParam param;

 	InitFormatParam(param);

 	param.iMaxHeight = KMaxTInt;

 	TTmLineInfo info;

 	int height_increase = 0;

 	int paragraphs_increase = 0;

 	int cur_par = 0;

 	int desired_par = 0;

 	int pixels_to_scroll = 0;

 	if (aPars > 0)

 		{

 		if (iText->YPosToLine(iBandTop,info))

 			cur_par = info.iParNumber;

 		else

 			User::Leave(EPosNotFormatted);

 		if (info.iParTop < iBandTop)

 			aPars--;

 		desired_par = cur_par - aPars;

 		while (desired_par < 0 && iText->AddParL(param,TRUE,height_increase,paragraphs_increase))

 			{

 			iBandTop += height_increase;

 			desired_par += paragraphs_increase;

 			}

 		aPars = -desired_par;

 		if (desired_par < 0)

 			desired_par = 0;

 		if (!iText->ParNumberToLine(desired_par,0,info))

 			User::Leave(EPosNotFormatted);

 		pixels_to_scroll = iBandTop - info.iOuterRect.iTl.iY;

 		}

 	else if (aPars < 0)

 		{

 		int band_bottom = iBandTop + VisibleHeightInPixels();

 		// Extend formatting until the visible height is filled.

 		param.iEndChar = KMaxTInt;

 		param.iMaxHeight = band_bottom - iText->LayoutHeight();

 		if(param.iMaxHeight > 0)

 			{

 			iText->ExtendFormattingDownwardsL(param);

 			}

 		if (iText->YPosToLine(band_bottom - 1,info))

 			cur_par = info.iParNumber;

 		else

 			User::Leave(EPosNotFormatted);

 		if (!((info.iFlags & TTmLineInfo::EParEnd) && info.iOuterRect.iBr.iY == band_bottom))

 			aPars++;

 		desired_par = cur_par - aPars;

 		int last_par = iText->Paragraphs() - 1;

 		while (desired_par > last_par && iText->AddParL(param, EFalse, height_increase,paragraphs_increase))

 			last_par += paragraphs_increase;

 		aPars = last_par - desired_par;

 		if (desired_par > last_par)

 			desired_par = last_par;

 		if (!iText->ParNumberToLine(desired_par,KMaxTInt,info))

 			iText->AddParL(param, EFalse, height_increase, paragraphs_increase);

 		if (!iText->ParNumberToLine(desired_par,KMaxTInt,info))

 			User::Leave(EPosNotFormatted);

 		pixels_to_scroll = band_bottom - info.iOuterRect.iBr.iY;

 		}

 	return ScrollL(pixels_to_scroll,aScrollBlankSpace);

 	}

 /** Scrolls the text up or down by aNumLines lines, disallowing blank space at

 the bottom of the visible area if aScrollBlankSpace is

 CTextLayout::EFDisallowScrollingBlankSpace.

 Do not use if a CTextView object owns this CTextLayout object.

 @param aNumLines The number of lines to scroll; may be a positive or negative

 value. On return, contains the number of lines not scrolled; that is, the

 requested number, minus the number actually scrolled.

 @param aScrollBlankSpace Only relevant when scrolling downwards.

 CTextLayout::EFAllowScrollingBlankSpace allows blank space to scroll into the

 visible area. CTextLayout::EFDisallowScrollingBlankSpace prevents blank space

 from scrolling into the visible area.

 @pre aLines must not scroll the display beyond the formatted range. If aLines

 scrolls beyond the formatted range, this method will leave with the error code

 CTextLayout::EPosNotFormatted

 @return The number of pixels actually scrolled. */

 EXPORT_C TInt CTextLayout::ScrollLinesL(TInt& aLines,TAllowDisallow aScrollBlankSpace)

 	{

 	TTmFormatParam param;

 	InitFormatParam(param);

 	param.iMaxHeight = KMaxTInt;

 	TTmLineInfo info;

 	int height_increase = 0;

 	int paragraphs_increase = 0;

 	int lines_scrolled = aLines;

 	int visible_height = VisibleHeightInPixels();

 	if (aLines > 0)			// bring aLines lines into view at the top of the display

 		{

 		int desired_top_line_number = 0;

 		for (;;)

 			{

 			// Find the line number of the first visible line.

 			TBool partial_line = FALSE;

 			int top_line_number = 0;

 			if (iBandTop >= iText->LayoutHeight())

 				top_line_number = iText->Lines();

 			else

 				{

 				if (iText->YPosToLine(iBandTop,info))

 					top_line_number = info.iLineNumber;

 				else

 				    {

 					OstTrace0( TRACE_DUMP, DUP1_CTEXTLAYOUT_SCROLLLINESL, "EPosNotFormatted" );

 					User::Leave(EPosNotFormatted);

 					}

 				partial_line = iBandTop > info.iOuterRect.iTl.iY;

 				}

 			// Find the line number of the desired first visible line.

 			// Defect fix for INC015850. Changed IF so that if the currently

 			// visible top line is as tall or taller (due to a large font or picture)

 			// than the visible height of the view our desired top line remains

 			// the next one above so that a scroll takes place.

 			desired_top_line_number = top_line_number - aLines;

 			if (partial_line && (info.iOuterRect.iBr.iY-info.iOuterRect.iTl.iY < visible_height))

 				desired_top_line_number++;

 			// If the desired first visible line number is negative, more lines need to be formatted.

 			if (desired_top_line_number >= 0)

 				break;

 			if (!iText->AddParL(param,TRUE,height_increase,paragraphs_increase))

 				break;

 			iBandTop += height_increase;

 			}

 		if (desired_top_line_number < 0)

 			{

 			lines_scrolled += desired_top_line_number;

 			desired_top_line_number = 0;

 			}

 		aLines -= lines_scrolled;

 		if (lines_scrolled)

 			{

 			if (!iText->LineNumberToLine(desired_top_line_number,info))

 			    {

 			    OstTrace0( TRACE_DUMP, CTEXTLAYOUT_SCROLLLINESL, "EPosNotFormatted" );

 			    User::Leave(EPosNotFormatted);

 			    }

 			// if the line to be scrolled to is taller than the screen, we want

 			// to make sure that the baseline is not scrolled off the screen.

 			if (visible_height < info.iBaseline - info.iOuterRect.iTl.iY)

 				return ScrollL(iBandTop + visible_height - info.iBaseline, aScrollBlankSpace);

 			return ScrollL(iBandTop - info.iOuterRect.iTl.iY,aScrollBlankSpace);

 			}

 		else

 			return 0;

 		}

 	else if (aLines < 0)	// bring aLines lines into view at the bottom of the display

 		{

 		if (iScrollFlags & EFScrollOnlyToTopsOfLines)

 			{

 			// If we are restricting scroll to the tops of lines, then lines at

 			// bottom are irrelevant, so all we do is lose the top line.

 			if (!iText->YPosToLine(iBandTop, info))

 			    {

 			    OstTrace0( TRACE_DUMP, DUP2_CTEXTLAYOUT_SCROLLLINESL, "EPosNotFormatted" );

 			    User::Leave(EPosNotFormatted);

 			    }

 			return ScrollL(-info.iOuterRect.Height(), aScrollBlankSpace);

 			}

 		int desired_bottom_line_number = 0;

 		int band_bottom = iBandTop + visible_height;

 		int last_formatted_line = iText->Lines() - 1;

 		// Extend formatting until the visible height is filled.

 		param.iEndChar = KMaxTInt;

 		param.iMaxHeight = band_bottom - iText->LayoutHeight();

 		if(param.iMaxHeight > 0)

 			{

 			iText->ExtendFormattingDownwardsL(param);

 			}	

 		for (;;)

 			{

 			// Find the line number of the last visible line.

 			TBool partial_line = FALSE;

 			int bottom_line_number = 0;

 			if (iText->YPosToLine(band_bottom - 1,info))

 				bottom_line_number = info.iLineNumber;

 			else

 			    {

 			    OstTrace0( TRACE_DUMP, DUP3_CTEXTLAYOUT_SCROLLLINESL, "EPosNotFormatted" );

 			    User::Leave(EPosNotFormatted);

 			    }

 			partial_line = band_bottom < info.iOuterRect.iBr.iY;

 			// Find the line number of the desired last visible line.

 			desired_bottom_line_number = bottom_line_number - aLines;

 			if (partial_line)

 				desired_bottom_line_number--;

 			// If the desired last visible line number is greater than the last line, more lines need to be formatted.

 			if (desired_bottom_line_number <= last_formatted_line)

 				break;

 			if (!AddFormattingAtEndL(param, height_increase,paragraphs_increase))

 				break;

 			last_formatted_line = iText->Lines() - 1;

 			}

 		int shortfall = desired_bottom_line_number - last_formatted_line;

 		if (shortfall > 0)

 			{

 			lines_scrolled += shortfall;

 			desired_bottom_line_number = last_formatted_line;

 			}

 		aLines -= lines_scrolled;

 		if (lines_scrolled)

 			{

 			if (!iText->LineNumberToLine(desired_bottom_line_number,info))

 			    {

 			    OstTrace0( TRACE_DUMP, DUP4_CTEXTLAYOUT_SCROLLLINESL, "EPosNotFormattedL" );

 			    User::Leave(EPosNotFormatted);

 			    }

 			return ScrollL(band_bottom - info.iOuterRect.iBr.iY,aScrollBlankSpace);

 			}

 		else

 			return 0;

 		}

 	else

 		return 0;

 	}

 /** Scrolls the text up or down by aPixels pixels, disallowing blank space at

 the bottom of the visible area if aScrollBlankSpace is

 CTextLayout::EFDisallowScrollingBlankSpace.

 The return value (not aPixels, as you would expect from ScrollParagraphsL() and

 ScrollLinesL()) contains the number of pixels not successfully scrolled, that

 is, the original value of aPixels, minus the number of pixels actually

 scrolled. On return, aPixels is set to the number of pixels actually scrolled.

 Do not use if a CTextView object owns this CTextLayout object.

 @param aPixels The number of pixels to scroll; may be a positive or negative

 value. On return, contains the number of pixels actually scrolled.

 @param aScrollBlankSpace Only relevant when scrolling downwards.

 CTextLayout::EFAllowScrollingBlankSpace allows blank space to scroll into the

 visible area. CTextLayout::EFDisallowScrollingBlankSpace prevents blank space

 from scrolling into the visible area.

 @return The difference between the requested number of pixels to scroll and the

 number of pixels actually scrolled. */

 EXPORT_C TInt CTextLayout::ChangeBandTopL(TInt& aPixels,TAllowDisallow aScrollBlankSpace)

 	{

 	int desired_pixels = aPixels;

 	aPixels = ScrollL(aPixels,aScrollBlankSpace);

 	return desired_pixels - aPixels;

 	}

 /** Scrolls the text up or down by aPixels pixels, allowing blank space at

 top and bottom of the visible area, which means the scrolling can go beyond the

 top or bottom border.

 Do not use if a CTextView object owns this CTextLayout object.

 @param aPixels The number of pixels to scroll; may be a positive or negative

 value. The actual scrolled pixel number is always identical to aPixels*/

 EXPORT_C void CTextLayout::ChangeBandTopNoLimitBorderL(TInt aPixels)

     {

     ScrollL(aPixels,EFAllowScrollingBlankSpace,ETrue,ETrue);

     }

 /**

  * Finds a position (in pixels, from the top of the window) where the cursor

  * can be such that its line will be fully visible. If this is not possible,

  * then return one with its baseline visible. If this is not possible, we don't

  * care what the answer is.

  */

 TInt CTextLayout::SuggestCursorPos(TInt aCurrentCursorPos) const

 	{

 	int visible_height = VisibleHeightInPixels();

 	TTmLineInfo info;

 	if (iText->YPosToLine(iBandTop + aCurrentCursorPos, info))

 		{

 		TBool currentLineHasBaselineVisible =

 			(TBool)(iBandTop <= info.iBaseline

 			&& info.iBaseline < iBandTop + visible_height);

 		TInt tryThisLine = -1;

 		// find a good line to put the cursor on.

 		if (info.iOuterRect.iTl.iY < iBandTop)

 			{

 			// try next line

 			tryThisLine = info.iLineNumber + 1;

 			}

 		else if (iBandTop + visible_height < info.iOuterRect.iBr.iY)

 			{

 			tryThisLine = info.iLineNumber - 1;

 			}

 		if (0 <= tryThisLine && iText->LineNumberToLine(tryThisLine, info))

 			{

 			if (iBandTop <= info.iOuterRect.iTl.iY

 				&& info.iOuterRect.iBr.iY < iBandTop + visible_height)

 				// this line fully visible

 				aCurrentCursorPos = info.iBaseline - iBandTop;

 			else if (!currentLineHasBaselineVisible

 				&& iBandTop <= info.iBaseline

 				&& info.iBaseline < iBandTop + visible_height)

 				// not fully visible, but its baseline is, and the original

 				// line's baseline was not

 				aCurrentCursorPos = info.iBaseline - iBandTop;

 			}

 		}

 	return aCurrentCursorPos;

 	}

 /** Scrolls up by a page (that is the band height as set by SetBandHeight(), or

 half that amount if scrolling over lines taller than this), moving the text

 downwards. The current desired vertical cursor position is passed in

 aYCursorPos and updated to a new suggested position as near as possible to it,

 but within the visible text and on a baseline.

 Do not use if a CTextView object owns this CTextLayout object.

 @param aYCursorPos The current desired vertical cursor position. On return,

 updated to a new suggested position as near as possible to it.

 @param aPixelsScrolled On return, contains the number of pixels scrolled. */

 EXPORT_C void CTextLayout::PageUpL(TInt& aYCursorPos,TInt& aPixelsScrolled)

 	{

 	// Move the cursor into the visible area.

 	int visible_height = VisibleHeightInPixels();

 	if (aYCursorPos < 0)

 		aYCursorPos = 0;

 	else if (aYCursorPos > visible_height)

 		aYCursorPos = visible_height - 1;

 	TTmLineInfo info;

 	// position the top of the screen must be at least as low as

 	TInt longestScrollTo = iBandTop + visible_height

 		- visible_height * KMaxProportionOfScreenToScroll/1000;

 	// position the top of the screen must be at least as high as

 	TInt shortestScrollTo = iBandTop + visible_height

 		- visible_height * KMinProportionOfScreenToScroll/1000;

 	TInt desiredScrollTo = shortestScrollTo;

 	// find the line at the top of the screen

 	// (we cannot find the one that includes the first pixel off the screen

 	// because it might not have been formatted yet)

 	if  (iText->YPosToLine(iBandTop, info))

 		{

 		// subtract one from the line number if this was on the screen

 		TInt line = info.iLineNumber

 			- (info.iOuterRect.iTl.iY < iBandTop? 0 : 1)

 			+ KNumberOfLinesToKeepVisibleDuringScroll;

 		if (iText->LineNumberToLine(Max(0, line), info))

 			desiredScrollTo = info.iOuterRect.iTl.iY;

 		}

 	if (shortestScrollTo < desiredScrollTo)

 		desiredScrollTo = shortestScrollTo;

 	else if (desiredScrollTo < longestScrollTo)

 		desiredScrollTo = longestScrollTo;

 	aPixelsScrolled = ScrollL(iBandTop + visible_height - desiredScrollTo,

 		EFDisallowScrollingBlankSpace);

 	aYCursorPos = aPixelsScrolled == 0?

 		0

 		: SuggestCursorPos(aYCursorPos);

 	}

 /** Scrolls down by a page (that is the band height as set by SetBandHeight(),

 or half that amount if scrolling over lines taller than this), moving the text

 upwards. The current desired vertical cursor position is passed in aYCursorPos

 and updated to a new suggested position as near as possible to it, but within

 the visible text and on a baseline.

 Do not use if a CTextView object owns this CTextLayout object.

 @param aYCursorPos The current desired vertical cursor position. On return,

 updated to a new suggested position as near as possible to it.

 @param aPixelsScrolled On return, contains the number of pixels scrolled - a

 negative value. */

 EXPORT_C void CTextLayout::PageDownL(TInt& aYCursorPos,TInt& aPixelsScrolled)

 	{

 	// Move the cursor into the visible area.

 	int visible_height = VisibleHeightInPixels();

 	if (aYCursorPos < 0)

 		aYCursorPos = 0;

 	else if (aYCursorPos > visible_height)

 		aYCursorPos = visible_height - 1;

 	TTmLineInfo info;

 	// position the bottom of the screen must be at least as high as

 	TInt longestScrollTo = iBandTop +

 		visible_height * KMaxProportionOfScreenToScroll/1000;

 	// position the bottom of the screen must be at least as low as

 	TInt shortestScrollTo = iBandTop + visible_height * KMinProportionOfScreenToScroll/1000;

 	TInt desiredScrollTo = shortestScrollTo;

 	// find the line at the bottom of the screen

 	// (we cannot find the one that includes the first pixel off the screen

 	// because it might not have been formatted yet)

 	if  (iText->YPosToLine(iBandTop + visible_height - 1, info))

 		{

 		// add one to the line number if this was on the screen

 		TInt line = info.iLineNumber

 			+ (iBandTop + visible_height < info.iBaseline? 0 : 1)

 			- KNumberOfLinesToKeepVisibleDuringScroll;

 		if (iText->LineNumberToLine(Max(0, line), info))

 			desiredScrollTo = info.iOuterRect.iBr.iY;

 		}

 	if (desiredScrollTo < shortestScrollTo)

 		desiredScrollTo = shortestScrollTo;

 	else if (longestScrollTo < desiredScrollTo)

 		desiredScrollTo = longestScrollTo;

 	aPixelsScrolled = ScrollL(iBandTop - desiredScrollTo,

 		EFDisallowScrollingBlankSpace);

 	aYCursorPos = aPixelsScrolled == 0?

 		visible_height - 1

 		: SuggestCursorPos(aYCursorPos);

 	if (-visible_height > aPixelsScrolled)

 	    {

 	    OstTrace0( TRACE_DUMP, CTEXTLAYOUT_PAGEDOWNL, "EPageScrollError" );

 	    }

 	__ASSERT_DEBUG(-visible_height <= aPixelsScrolled,

 		Panic(EPageScrollError));

 	if (0 > aYCursorPos || aYCursorPos > visible_height)

 	    {

 	    OstTrace0( TRACE_DUMP, DUP1_CTEXTLAYOUT_PAGEDOWNL, "EPageScrollError" );

 	    }

 	__ASSERT_DEBUG(0 <= aYCursorPos && aYCursorPos <= visible_height,

 		Panic(EPageScrollError));

 	}

 /** Reformats to reflect a single character edit.

 Do not use if a CTextView object owns this CTextLayout object.

 @param aType Indicates the type of edit which has taken place.

 CTextLayout::EFCharacterInsert (the default) for a character insertion,

 CTextLayout::EFParagraphDelimiter for a paragraph delimiter insertion,

 CTextLayout::EFLeftDelete or CTextLayout::EFRightDelete for a character or

 paragraph delimiter deletion to the left or right of the document position.

 @param aCursorPos The document position at which the edit took place, before

 the edit. If this position is not formatted, a panic occurs; it is modified in

 accordance with the edit.

 @param aGood On return, the y coordinate of the top of the paragraph following

 the paragraph which has been edited, before the edit.

 @param aFormattedUpTo On return, the y coordinate of the bottom of the

 reformatted line or lines, after the edit.

 @param aFormattedFrom On return, the vertical layout coordinate of the top of

 the reformatted line or lines, after the edit.

 @param aScroll The number of pixels by which the text had to be scrolled

 (positive means text moved down).

 @param aFormatChanged ETrue if text is to be reformatted from the start of the

 paragraph the cursor was on before the edit, EFalse if from the start of the

 line the cursor was on before the edit.

 @return EFalse if no more lines need to be reformatted. ETrue if some more lines

 need to be reformatted. */

 EXPORT_C TBool CTextLayout::HandleCharEditL(TUint aType,TInt& aCursorPos,TInt& aGood,TInt& aFormatBottom,

 											TInt& aFormatTop,TInt& aScroll,TBool aFormatFromStartOfPar)

 	{

 	if (iSource->iFormatMode == CLayoutData::EFPrintPreviewMode)

 	    {

 	    OstTrace0( TRACE_FATAL, DUP2_CTEXTLAYOUT_HANDLECHAREDITL, "EPrintPreviewModeError" );

 	    }

 	__ASSERT_ALWAYS(iSource->iFormatMode != CLayoutData::EFPrintPreviewMode,Panic(EPrintPreviewModeError));

 	if (aType > EFRightDelete)

 	    {

 	    OstTrace0( TRACE_FATAL, CTEXTLAYOUT_HANDLECHAREDITL, "EBadCharacterEditType" );

 	    }

 	__ASSERT_ALWAYS(aType <= EFRightDelete,Panic(EBadCharacterEditType));

 	if (!(!aFormatFromStartOfPar || aType == EFRightDelete || aType == EFLeftDelete))

 	    {

 	    OstTrace0( TRACE_FATAL, DUP1_CTEXTLAYOUT_HANDLECHAREDITL, "EBadCharacterEditType" );

 	    }

 	__ASSERT_ALWAYS(!aFormatFromStartOfPar || aType == EFRightDelete || aType == EFLeftDelete,Panic(EBadCharacterEditType));

 	if (aCursorPos < iText->StartChar() || aCursorPos >= iText->EndChar())

 	    {

 	    OstTrace0( TRACE_FATAL, DUP3_CTEXTLAYOUT_HANDLECHAREDITL, "ECharacterNotFormatted" );

 	    }

 	__ASSERT_ALWAYS(aCursorPos >= iText->StartChar() && aCursorPos < iText->EndChar(),Panic(ECharacterNotFormatted));

 	// Mark the entire paragraph invalid if background formatting is taking place.

 	iParInvalid = iUnformattedStart != KMaxTInt;

 	// Cancel any pending background formatting, which has now been invalidated by the change.

 	iUnformattedStart = KMaxTInt;

 	// Adjust the cursor position and determine the range of characters to reformat.

 	TTmReformatParam reformat_param;

 	reformat_param.iParInvalid = iParInvalid;

 	switch (aType)

 		{

 		case EFCharacterInsert:

 		case EFParagraphDelimiter:

 			{

 			reformat_param.iStartChar = aCursorPos++;

 			reformat_param.iNewLength = 1;

 			// surrogate support

 			TPtrC textForSurrogate;

 			TTmCharFormat formatForSurrogate;

 			iSource->GetText(aCursorPos-1, textForSurrogate, formatForSurrogate);

 			if ( textForSurrogate.Length() > 1 )

 				{

 				TUint highSurrogate = textForSurrogate[0];

 				TUint lowSurrogate = textForSurrogate[1];

 				if ( TChar::IsHighSurrogate( highSurrogate ) && TChar::IsLowSurrogate( lowSurrogate ) )

 					{

 					// if we are inserting a surrogate pair, do not break the pair

 					aCursorPos++;

 					reformat_param.iNewLength++;

 					}

 				}

 			break;

 			}

 		case EFLeftDelete:

 			{

 			reformat_param.iStartChar = --aCursorPos;

 			reformat_param.iOldLength = 1;

 			// surrogate support

 			TPtrC textForSurrogate;

 			TTmCharFormat formatForSurrogate;

 			if (aCursorPos >= 1)

 				{

 				iSource->GetText(aCursorPos-1, textForSurrogate, formatForSurrogate);

 				if ( textForSurrogate.Length() > 1 )

 					{

 					TUint highSurrogate = textForSurrogate[0];

 					TUint lowSurrogate = textForSurrogate[1];

 					if ( TChar::IsHighSurrogate( highSurrogate ) && TChar::IsLowSurrogate( lowSurrogate ) )

 						{

 						// if we are deleting a surrogate pair, do not break the pair

 						reformat_param.iStartChar = --aCursorPos;

 						reformat_param.iOldLength++;

 						}

 					}

 				}

 			break;

 			}

 		case EFRightDelete:

 			{

 			reformat_param.iStartChar = aCursorPos;

 			reformat_param.iOldLength = 1;

 			// surrogate support

 			TPtrC textForSurrogate;

 			TTmCharFormat formatForSurrogate;

 			iSource->GetText(aCursorPos, textForSurrogate, formatForSurrogate);

 			if ( textForSurrogate.Length() > 1 )

 				{

 				TUint highSurrogate = textForSurrogate[0];

 				TUint lowSurrogate = textForSurrogate[1];

 				if ( TChar::IsHighSurrogate( highSurrogate ) && TChar::IsLowSurrogate( lowSurrogate ) )

 					{

 					reformat_param.iOldLength++;

 					}

 				}

 			break;

 			}

 		default: break;

 		}

 	// Set up the formatting parameters.

 	TTmFormatParam param;

 	InitFormatParam(param);

 	param.iMaxHeight = KMaxTInt;

 	// Format the whole band if necessary.

 	TTmDocPos cursorPos(aCursorPos, EFalse);

 	if (reformat_param.iStartChar < iText->StartChar() || reformat_param.iStartChar + reformat_param.iOldLength >= iText->EndChar())

 		{

 		FormatBandL(reformat_param.iStartChar,reformat_param.iStartChar + reformat_param.iOldLength);

 		aFormatTop = 0;

 		aFormatBottom = iText->LayoutHeight() - iBandTop;

 		aGood = aFormatBottom;

 		aScroll = 0;

 		ScrollDocPosIntoViewL(cursorPos);

 		return FALSE;

 		}

 	// Reformat the chosen range.

 	reformat_param.iMaxExtraLines = KMaxExtraLines;

 	TTmReformatResult result;

 	iText->FormatL(param,reformat_param,result);

 	result.iRedrawRect.Move(0,-iBandTop);

 	iUnformattedStart = result.iUnformattedStart;

 	// Scroll if necessary and extend the redraw area to include material scrolled into view.

 	aScroll = ScrollDocPosIntoViewL(cursorPos);

 	if (aScroll > 0)

 		result.iRedrawRect.iBr.iY += aScroll;

 	else

 		result.iRedrawRect.iTl.iY += aScroll;

 	// Return coordinates.

 	aFormatTop = result.iRedrawRect.iTl.iY;

 	aFormatBottom = result.iRedrawRect.iBr.iY;

 	aGood = result.iUnchangedTop - iBandTop;

 	// Add new paragraphs if necessary.

 	int visible_height = VisibleHeightInPixels();

 	param.iEndChar = KMaxTInt;

 	param.iMaxHeight = (iBandTop + visible_height) - iText->LayoutHeight();

 	if(param.iMaxHeight > 0)

 		{

 		iText->ExtendFormattingDownwardsL(param);

 		}

 	//remove formatting from the end if necessary

 	PruneFormatL(EFalse);

 	// Return TRUE if more text needs to be formatted.

 	return iUnformattedStart < KMaxTInt;

 	}

 /** Reformats to reflect changes to a block of text.

 Do not use if a CTextView object owns this CTextLayout object.

 @param aSelection The start and new length of the changed block. When

 inserting, specify the insertion position. When deleting, specify the position

 of the start of the deletion. When reformatting, specify the start and length

 of the reformatted block.

 @param aOldCharsChanged The old length of the changed block. When inserting,

 specify zero. When deleting, specify the number of deleted characters. When

 reformatting, specify the number of reformatted characters.

 @param aViewChanges On return, contains the top of the reformatted text

 (iFormattedFrom), the bottom of the reformatted text (iFormattedTo), the amount

 by which the text above the reformatted text has scrolled (iScrollAtTop) and

 the amount by which the text below the reformatted text has scrolled

 (iScrollAtBottom) (positive values mean the text moves down).

 @param aFormatChanged Indicates whether the paragraph format for the first or

 last affected paragraph has changed, meaning that the text to be reformatted

 must extend out to paragraph boundaries and cannot be restricted to only some

 lines. */

 EXPORT_C void CTextLayout::HandleBlockChangeL(TCursorSelection aSelection,TInt aOldLength,

 											  TViewRectChanges& aChanges,TBool aFormatFromStartOfPar)

 	{

 	if (iSource->iFormatMode == CLayoutData::EFPrintPreviewMode)

 	    {

 	    OstTrace0( TRACE_FATAL, CTEXTLAYOUT_HANDLEBLOCKCHANGEL, "EPrintPreviewModeError" );

 	    }

 	__ASSERT_ALWAYS(iSource->iFormatMode != CLayoutData::EFPrintPreviewMode,Panic(EPrintPreviewModeError));

 	// Do nothing if the selection is outside the formatted range.

 	if (aSelection.LowerPos() > iText->EndChar() || aSelection.HigherPos() < iText->StartChar())

 		{

 		aChanges.iFormattedFrom = 0;

 		aChanges.iFormattedTo = 0;

 		aChanges.iScrollAtTop = 0;

 		aChanges.iScrollAtBottom = 0;

 		return;

 		}

 	// Format the whole band if necessary.

 	TTmDocPos cursorPos(aSelection.iCursorPos,

 		aSelection.iCursorPos < aSelection.iAnchorPos? ETrue : EFalse);

 	if (aSelection.LowerPos() < iText->StartChar() || aSelection.LowerPos() + aOldLength >= iText->EndChar())

 		{

 		FormatBandL(aSelection.iCursorPos,aSelection.iCursorPos);

 		aChanges.iFormattedFrom = 0;

 		aChanges.iFormattedTo = VisibleHeightInPixels();

 		aChanges.iScrollAtTop = 0;

 		aChanges.iScrollAtBottom = 0;

 		ScrollDocPosIntoViewL(cursorPos);

 		return;

 		}

 	// Reformat the chosen range.

 	TTmFormatParam param;

 	InitFormatParam(param);

 	param.iMaxHeight = KMaxTInt;

 	TTmReformatParam reformat_param;

 	reformat_param.iStartChar = aSelection.LowerPos();

 	reformat_param.iOldLength = aOldLength;

 	reformat_param.iNewLength = aSelection.Length();

 	reformat_param.iParFormatChanged = aFormatFromStartOfPar;

 	TTmReformatResult result;

 	iText->FormatL(param,reformat_param,result);

 	result.iRedrawRect.Move(0,-iBandTop);

 	// Scroll if necessary.

 	int dy;

 	if(iTextViewCursorPos)

 		{

 		dy = ScrollDocPosIntoViewL(iTextViewCursorPos->TmDocPos());

 		iTextViewCursorPos = NULL;

 		}

 	else

 		{

 		dy = ScrollDocPosIntoViewL(cursorPos);

 		}

 	result.iRedrawRect.Move(0,dy);

 	aChanges.iFormattedFrom = result.iRedrawRect.iTl.iY;

 	aChanges.iFormattedTo = result.iRedrawRect.iBr.iY;

 	aChanges.iScrollAtTop = dy;

 	aChanges.iScrollAtBottom = dy + result.iHeightChange;

 	// Extend formatting to fill the band if necessary.

 	int visible_height = VisibleHeightInPixels();

 	param.iEndChar = KMaxTInt;

 	param.iMaxHeight = (iBandTop + visible_height) - iText->LayoutHeight();

 	if(param.iMaxHeight > 0)

 		{

 		iText->ExtendFormattingDownwardsL(param);

 		}

 	//remove formatting from the end if necessary

 	PruneFormatL(EFalse);

 	}

 /** Reformats to reflect the addition of one or more complete paragraphs at the

 end of the text.

 Do not use if a CTextView object owns this CTextLayout object.

 @param aFirstPixel On return, the top y coordinate of the added material.

 @param aLastPixel On return, the bottom y coordinate of the added material.

 */

 EXPORT_C void CTextLayout::HandleAdditionalCharactersAtEndL(TInt& aNewTextTop,TInt& aNewTextBottom)

 	{

 	aNewTextTop = aNewTextBottom = iText->LayoutHeight() - iBandTop;

 	int format_required = BandHeightInPixels() - aNewTextBottom;

 	if (format_required > 0)

 		{

 		TTmFormatParam param;

 		InitFormatParam(param);

 		param.iMaxHeight = format_required;

 		TInt oldHeight = iText->LayoutHeight();

 		iText->ExtendFormattingDownwardsL(param);

 		aNewTextBottom += (iText->LayoutHeight() - oldHeight);

 		}

 	}

 /** Reformats to reflect changes to the space above and below paragraphs

 (CParaFormat::iSpaceBeforeInTwips and iSpaceAfterInTwips).

 Do not use if a CTextView object owns this CTextLayout object.

 @deprecated 6.1 Use FormatBandL()

 */

 EXPORT_C void CTextLayout::ReformatVerticalSpaceL()

 	{

 	// Reformat the whole band; only space above and below paragraphs has changed, but who cares?

 	FormatBandL();

 	}

 /** Temporarily changes the vertical alignment of the text with respect to the

 visible height.

 Notes:

 Not generally useful.

 Do not use if a CTextView object owns this CTextLayout object.

 @param aVerticalAlignment Specifies whether the formatted text should be placed

 at the top (CParaFormat::ETopAlign), vertical centre (CParaFormat::ECenterAlign

 or CParaFormat::EJustifiedAlign) or bottom (CParaFormat::EBottomAlign) of the

 band. CParaFormat::EUnspecifiedAlign or CParaFormat::ECustomAlign may also be

 specified. These values cause the baseline of the first formatted line to be

 positioned 82% of the way down the band (provided for the Agenda's

 application's year view). */

 EXPORT_C void CTextLayout::AdjustVerticalAlignment(CParaFormat::TAlignment aVerticalAlignment)

 	{

 	int excess = BandHeight() - FormattedHeightInPixels();

 	int space_before = 0;

 	if (IsFormattingBand())

 	    {

 	    OstTrace0( TRACE_FATAL, CTEXTLAYOUT_ADJUSTVERTICALALIGNMENT, "EMustFormatAllText" );

 	    }

 	__ASSERT_ALWAYS(!IsFormattingBand(),Panic(EMustFormatAllText));

 	TTmLineInfo info;

 	switch (aVerticalAlignment)

 		{

 		case CParaFormat::EAbsoluteLeftAlign:

 		case CParaFormat::ETopAlign:

 			break;

 		case CParaFormat::ECenterAlign:

 		case CParaFormat::EJustifiedAlign:

 			space_before = excess / 2;

 			break;

 		case CParaFormat::EAbsoluteRightAlign:

 		case CParaFormat::EBottomAlign:

 			space_before = excess;

 			break;

 		case CParaFormat::EUnspecifiedAlign:

 		case CParaFormat::ECustomAlign:

 			if (iText->LineNumberToLine(0,info))

 				{

 				space_before = CLayoutData::EFBaseLinePosition * BandHeight() / 100 - info.iBaseline;

 				}

 			else

 				{

 				space_before = CLayoutData::EFBaseLinePosition * BandHeight() / 100;

 				}

 			break;

 		}

 	iBandTop = -space_before;

 	}

 static TInt SingleBorderWidthInPixels(const MGraphicsDeviceMap* aGd,const TParaBorder& aBorder,TBool aHoriz)

 	{

 	TInt width = aBorder.iThickness;

 	if (width > 0)

 		{

 		if (aHoriz)

 			width = aGd->VerticalTwipsToPixels(width);

 		else

 			width = aGd->HorizontalTwipsToPixels(width);

 		}

 	else

 		width = 1;

 	return width;

 	}

 /** Draws paragraph borders, optionally with a background colour for the border

 and a clip region. Provided for applications that display a menu of border

 styles, like a wordprocessor.

 @param aGd Provides twip-to-pixel conversion.

 @param aGc Graphics context to which to draw the border. Its pen settings are

 overridden by the values specified by aBorder and its draw mode is set to