FCL/sf/os/textandloc: comparison textrendering/textformatting/tbox/LAYEMU.CPP

equal deleted inserted replaced

-:b9ad20498fb4
+:8b9155204a54
+/*
+* 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
+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;
+	__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)
+	{
+	__ASSERT_ALWAYS(0 == iBeginRedrawCount, Panic(EInvalidRedraw));
+	iBeginRedrawCount++;
+	iRedrawRect = aRect;
+	}
+void CTextLayout::ResetExternalDraw()
+	{
+	__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)
+		{
+		__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
+	{
+	__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);
+	__ASSERT_ALWAYS(PosIsFormatted(aDocPos1),Panic(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);
+	__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 = aEndDocPos;
+		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)
+	{
+	__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);
+		}
+	__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)
+	{
+	__ASSERT_DEBUG(aStartDocPos >= 0 && aStartDocPos <= DocumentLength(),Panic(EInvalidDocPos));
+	__ASSERT_DEBUG(aEndDocPos >= 0 && aEndDocPos <= DocumentLength(),Panic(EInvalidDocPos));
+	__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);
+			__ASSERT_DEBUG(isFormatted, Panic(EPosNotFormatted));
+			isFormatted = iText->ParNumberToLine(info.iParNumber,KMaxTInt,info);
+			__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
+					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))
+				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))
+				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
+				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))
+				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);
+	__ASSERT_DEBUG(-visible_height <= aPixelsScrolled,
+		Panic(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)
+	{
+	__ASSERT_ALWAYS(iSource->iFormatMode != CLayoutData::EFPrintPreviewMode,Panic(EPrintPreviewModeError));
+	__ASSERT_ALWAYS(aType <= EFRightDelete,Panic(EBadCharacterEditType));
+	__ASSERT_ALWAYS(!aFormatFromStartOfPar || aType == EFRightDelete || aType == EFLeftDelete,Panic(EBadCharacterEditType));
+	__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)
+	{
+	__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;
+	__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
+CGraphicsContext::EDrawModePEN.
+@param aRect The outer bounds of the border.
+@param aBorder Specifies the four sides of the border.
+@param aBackground If not null, the background colour, (used between double
+border lines, or between dots or dashes).
+@param aClipRegion If non-null, specifies a clip region.
+@param aDrawRect If non-null, and if aClipRegion is non-null, specifies a
+rectangle to be subtracted from the clip region. */
+EXPORT_C void CTextLayout::DrawBorders(const MGraphicsDeviceMap* aGd,CGraphicsContext& aGc,const TRect& aBoundingRect,
+									   const TParaBorderArray& aBorder,const TRgb* aBackground,TRegion *aClipRegion,
+									   const TRect* aDrawRect)
+	{
+	TPoint pointTl,pointBr;
+	TRect rect;
+	TInt * ptrStartLength=NULL;			//To stop a warning
+	TInt * ptrEndLength=NULL;			//To stop a warning
+	TInt * ptrStartWidth=NULL;			//To stop a warning
+	TInt * ptrEndWidth=NULL;			//To stop a warning
+	TInt directionOut=0;			//To stop a warning
+	TInt indexJoint1=0,indexJoint2=0;			//To stop a warning
+	TBool drawAsLine=EFalse;
+	TRect clipRect;
+	CGraphicsContext::TPenStyle	penStyle[4];
+	TInt widthInPixels[4];
+	TBool horiz;
+	const MFormParam* form_param = MFormParam::Get();
+	{for (TInt border=0; border<=3; border++)
+		{
+		TParaBorder::TLineStyle lineStyle=aBorder.iBorder[border].iLineStyle;
+		if (lineStyle == TParaBorder::ENullLineStyle)
+			{
+			penStyle[border]=CGraphicsContext::ENullPen;
+			widthInPixels[border]=0;
+			continue;
+			}
+		else
+			{
+			horiz=(border==CParaFormat::EParaBorderTop || border==CParaFormat::EParaBorderBottom);
+			widthInPixels[border]=SingleBorderWidthInPixels(aGd,aBorder.iBorder[border],horiz);
+			}
+		if (lineStyle==TParaBorder::ESolid || lineStyle==TParaBorder::EDouble)
+			{
+			penStyle[border]=CGraphicsContext::ESolidPen;
+			continue;
+			}
+		if (lineStyle == TParaBorder::EDashed)
+			penStyle[border]=CGraphicsContext::EDashedPen;
+		else if (lineStyle == TParaBorder::EDotted)
+			penStyle[border]=CGraphicsContext::EDottedPen;
+		else if (lineStyle == TParaBorder::EDotDash)
+			penStyle[border]=CGraphicsContext::EDotDashPen;
+		else if (lineStyle == TParaBorder::EDotDotDash)
+			penStyle[border]=CGraphicsContext::EDotDotDashPen;
+		}}
+	{for (TInt border=0; border<=3; border++)
+		{
+// Go to next border, if have NULL linestyle.
+		if (widthInPixels[border]==0)
+			continue;
+// Reset clipping region
+		clipRect.SetSize(TSize(0,0));
+// Draw as line if not solid lines.
+		if (penStyle[border]!=CGraphicsContext::ESolidPen)
+			drawAsLine=ETrue;
+		pointTl=aBoundingRect.iTl;
+		pointBr=aBoundingRect.iBr;
+		if (border==CParaFormat::EParaBorderLeft)
+			{
+			pointBr.iX=pointTl.iX;
+			ptrStartLength=&pointTl.iY;
+			ptrEndLength=&pointBr.iY;
+			ptrStartWidth=&pointTl.iX;
+			ptrEndWidth=&pointBr.iX;
+			directionOut=-1;
+			indexJoint1=CParaFormat::EParaBorderTop;
+			indexJoint2=CParaFormat::EParaBorderBottom;
+			}
+		if (border == CParaFormat::EParaBorderRight)
+			{
+			pointTl.iX=pointBr.iX;
+			ptrStartLength=&pointTl.iY;
+			ptrEndLength=&pointBr.iY;
+			ptrStartWidth=&pointTl.iX;
+			ptrEndWidth=&pointBr.iX;
+			directionOut=1;
+			indexJoint1=CParaFormat::EParaBorderTop;
+			indexJoint2=CParaFormat::EParaBorderBottom;
+			}
+		if (border == CParaFormat::EParaBorderTop)
+			{
+			pointBr.iY=pointTl.iY;
+			ptrStartLength=&pointTl.iX;
+			ptrEndLength=&pointBr.iX;
+			ptrStartWidth=&pointTl.iY;
+			ptrEndWidth=&pointBr.iY;
+			directionOut=-1;
+			indexJoint1=CParaFormat::EParaBorderLeft;
+			indexJoint2=CParaFormat::EParaBorderRight;
+			}
+		if (border == CParaFormat::EParaBorderBottom)
+			{
+			pointTl.iY=pointBr.iY;
+			ptrStartLength=&pointTl.iX;
+			ptrEndLength=&pointBr.iX;
+			ptrStartWidth=&pointTl.iY;
+			ptrEndWidth=&pointBr.iY;
+			directionOut=1;
+			indexJoint1=CParaFormat::EParaBorderLeft;
+			indexJoint2=CParaFormat::EParaBorderRight;
+			}
+		if (!ptrStartWidth || !ptrEndWidth)
+			{
+			continue;
+			}
+		if (drawAsLine)
+			{
+			if (directionOut<0)
+				{
+				(*ptrStartWidth)+=(widthInPixels[border]-1)/2;
+				(*ptrEndWidth)+=(widthInPixels[border]-1)/2;
+				}
+			else
+				{
+				(*ptrStartWidth)-=(widthInPixels[border]+2)/2;
+				(*ptrEndWidth)-=(widthInPixels[border]+2)/2;
+				}
+			(*ptrStartLength)+=(widthInPixels[border]-1)/2;
+			(*ptrEndLength)-=(widthInPixels[border])/2;
+			}
+		else
+			{
+			if (directionOut<0)
+				(*ptrEndWidth)+=widthInPixels[border];
+			else
+				(*ptrStartWidth)-=widthInPixels[border];
+			}
+// Colour of pen as is - NO logical combination with background etc.
+		aGc.SetDrawMode(CGraphicsContext::EDrawModePEN);
+		if (drawAsLine)
+			{
+// Must draw lines in background colour first, as have dotted/dashed lines.
+			aGc.SetPenSize(TSize(widthInPixels[border],widthInPixels[border]));
+			if (aBackground)
+				{
+				FormUtil::SetPenColor(form_param,&aGc,*aBackground);
+				aGc.SetPenStyle(CGraphicsContext::ESolidPen);
+				aGc.DrawLine(pointTl,pointBr);
+				}
+			FormUtil::SetPenColor(form_param,&aGc,aBorder.iBorder[border].iColor);
+			aGc.SetPenStyle(penStyle[border]);
+			aGc.DrawLine(pointTl,pointBr);
+			(*ptrStartWidth)-=(widthInPixels[border]-1)/2;
+			(*ptrEndWidth)+=(widthInPixels[border]+2)/2;
+			(*ptrStartLength)-=(widthInPixels[border]-1)/2;
+			(*ptrEndLength)+=(widthInPixels[border])/2;
+			clipRect.SetRect(pointTl,pointBr);
+			}
+		else
+			{
+// Brush
+			FormUtil::SetBrushColor(form_param,&aGc,aBorder.iBorder[border].iColor);
+			aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);
+			aGc.SetPenStyle(CGraphicsContext::ENullPen);
+			rect.SetRect(pointTl,pointBr);
+			aGc.DrawRect(rect);
+			clipRect=rect;
+			};
+// Repeat draw, for double border.
+		if (aBorder.iBorder[border].iLineStyle==TParaBorder::EDouble)	 // Now have only got solid border, drawn as rect.
+			{
+			__ASSERT_DEBUG(!drawAsLine,Panic(EDrawingBorderError));
+			(*ptrStartWidth)-=directionOut*widthInPixels[border];
+			(*ptrEndWidth)-=directionOut*widthInPixels[border];
+			(*ptrStartLength)+=widthInPixels[indexJoint1];
+			(*ptrEndLength)-=widthInPixels[indexJoint2];
+			if (aBackground)
+				{
+				rect.SetRect(pointTl,pointBr);
+				FormUtil::SetBrushColor(form_param,&aGc,*aBackground);
+				aGc.DrawRect(rect);
+				}
+			(*ptrStartWidth)-=directionOut*widthInPixels[border];
+			(*ptrEndWidth)-=directionOut*widthInPixels[border];
+			if (aBorder.iBorder[indexJoint1].iLineStyle==TParaBorder::EDouble)
+				(*ptrStartLength)+=widthInPixels[indexJoint1];
+			if (aBorder.iBorder[indexJoint2].iLineStyle==TParaBorder::EDouble)
+				(*ptrEndLength)-=widthInPixels[indexJoint2];
+			rect.SetRect(pointTl,pointBr);
+			FormUtil::SetBrushColor(form_param,&aGc,aBorder.iBorder[border].iColor);
+			aGc.DrawRect(rect);
+			clipRect.BoundingRect(rect);
+			};
+// Restore defaults
+		aGc.SetPenStyle(CGraphicsContext::ESolidPen);
+		aGc.SetPenSize(TSize(1,1));
+// Should change to BACKGROUND colour.
+		if (aBackground)
+			FormUtil::SetBrushColor(form_param,&aGc,*aBackground);
+// If have to clip region, then remove rectangles corresponding to the border region.
+		if (aClipRegion)
+			{
+			if (aDrawRect)
+				clipRect.Intersection(*aDrawRect);
+			aClipRegion->SubRect(clipRect);
+			}
+	}};
+	if (aClipRegion)
+		{
+		aClipRegion->Tidy();
+		((CWindowGc *) &aGc)->SetClippingRegion(*aClipRegion);
+		}
+	}
+/** Draws the text. Draws any lines that intersect aDrawRect, which is
+specified in window coordinates. The drawing parameters, including the graphics
+context, are given in aDrawTextLayoutContext. If aHighlight is non-null,
+highlights (by exclusive-ORing) the specified range of text.
+@param aDrawRect The function draw the lines within the visible area, which
+intersect this rectangle (which is specified in window coordinates).
+@param aDrawTextLayoutContext Provides a graphics context and other parameters
+for the function.
+@param aHighlight If not NULL, this range of text is drawn highlighted. */
+EXPORT_C void CTextLayout::DrawL(const TRect& aDrawRect,const TDrawTextLayoutContext* aDrawTextLayoutContext,
+								 const TCursorSelection* aHighlight)
+	{
+	// Set the drawing parameters in the MTmSource interface.
+	iSource->iFormParam = MFormParam::Get();
+	iSource->iLabelsGutter = aDrawTextLayoutContext->iGutterMarginWidth;
+	// Calculate the top left corner of the text.
+	TPoint top_left = aDrawTextLayoutContext->TopLeftText();
+	top_left.iY -= iBandTop;
+	// Get the graphics context.
+	CGraphicsContext* gc = aDrawTextLayoutContext->PrimaryGc();
+	/*
+	Clip the draw rectangle to the view rectangle, and clip it further to exclude
+	a final partial line if necessary.
+	*/
+	TRect clip_rect(aDrawRect);
+	clip_rect.Intersection(aDrawTextLayoutContext->iViewRect);
+	if (aDrawTextLayoutContext->UseClippingRect())
+		{
+		gc->SetClippingRect(clip_rect);
+		}
+	// Draw the text and background.
+	TBool isDrawingOnAWindowDC = aDrawTextLayoutContext->UseWindowGc();
+	if (isDrawingOnAWindowDC)
+		{
+		BeginRedraw(clip_rect);
+		}
+	iText->DrawLayout(*gc,top_left,clip_rect,&aDrawTextLayoutContext->iBackgroundColor,TRUE, aHighlight, iHighlightExtensions);
+	if (isDrawingOnAWindowDC)
+		{
+		EndRedraw();
+		}
+	iSource->iFormParam = NULL;
+	}
+/** Default constructor.
+The start and end positions are set to zero - Set() should be called to
+initialise the object. */
+EXPORT_C CTextLayout::TRangeChange::TRangeChange()
+	: iA(0), iB(0) {}
+/** Sets the start and end positions and whether the highlighting should be
+set or cleared.
+Called by the non-default constructor. The start and end positions can be
+specified in any order.
+@param aStart The start of the range.
+@param aEnd The end of the range.
+@param aChange Whether the highlighting should be set or cleared. */
+EXPORT_C void CTextLayout::TRangeChange::Set(TInt aStart, TInt aEnd,
+	CTextLayout::TRangeChange::TChangeType aChange)
+	{
+	if ((aChange == ESet && aStart < aEnd)
+		|| (!(aChange == ESet) && !(aStart < aEnd)))
+		{
+		iA = aStart;
+		iB = aEnd;
+		}
+	else
+		{
+		iA = aEnd;
+		iB = aStart;
+		}
+	}
+/** Constructor with a start and end position and whether the highlighting
+in the range should be set or cleared.
+The start and end positions can be specified in any order.
+@param aStart The start position.
+@param aEnd The end position.
+@param aChange Specifies whether the highlighting should be set or cleared.
+*/
+EXPORT_C CTextLayout::TRangeChange::TRangeChange(TInt aStart, TInt aEnd,
+	CTextLayout::TRangeChange::TChangeType aChange)
+	{
+	Set(aStart, aEnd, aChange);
+	}
+/** Gets the start and end of the range and whether the highlighting should be
+set or cleared.
+@param aStart On return, the start of the range. This is always the lesser of
+the two positions.
+@param aEnd On return, the end of the range. This is always the greater of the
+two positions.
+@return Specifies whether the highlighting should be set or cleared. */
+EXPORT_C CTextLayout::TRangeChange::TChangeType
+	CTextLayout::TRangeChange::Get(TInt& aStart, TInt& aEnd) const
+	{
+	if (iA < iB)
+		{
+		aStart = iA;
+		aEnd = iB;
+		return ESet;
+		}
+	aStart = iB;
+	aEnd = iA;
+	return EClear;
+	}
+/** Tests whether the range is not null.
+@return ETrue if the range is not of zero length, EFalse if the range is of zero
+length. */
+EXPORT_C TBool CTextLayout::TRangeChange::NonNull() const
+	{
+	return iA - iB;
+	}
+/** Clips the range so that its start and end positions are within the minimum
+and maximum positions specified.
+@param aMin The minimum value for the start and end of the range.
+@param aMax The maximum value for the start and end of the range.
+@return ETrue if the resulting range is not of zero length, EFalse if it is of
+zero length. */
+EXPORT_C TBool CTextLayout::TRangeChange::Clip(TInt aMin, TInt aMax)
+	{
+	if (iA < aMin)
+		iA = aMin;
+	if (iB < aMin)
+		iB = aMin;
+	if (aMax < iA)
+		iA = aMax;
+	if (aMax < iB)
+		iB = aMax;
+	return iA - iB;
+	}
+/** Try to cancel out sections of the ranges that overlap Merges two ranges of
+characters.
+Two successive calls to CTextLayout::Highlight() could cause unecessary flicker
+or redrawing if the arguments to each call overlap. For example, if extending a
+highlight involved removing the old highlight and then drawing the new one,
+this would cause visible flicker. This can be eliminated by calling this
+function to remove any overlap between the two ranges. If there is overlap,
+this range is set to the result of the merge, and the other range (aBuddy) is
+set to zero.
+When calling this function, it does not matter whether or not the two ranges
+overlap. Also it does not matter which range is the parameter and which is the
+calling object. After calling OptimizeWith(), it is guaranteed that the
+resulting ranges will not overlap, and they will represent the same change to
+the highlight as the original two ranges.
+See the code fragment in the class description for TRangeChange for an example
+of how this function is used.
+@param aBuddy The range of characters to combine with this range. */
+EXPORT_C void CTextLayout::TRangeChange::OptimizeWith(TRangeChange& aBuddy)
+	{
+	// we make this have the minimum iA and iB, and aBuddy have the maximum
+	if (aBuddy.iA < iA)
+		{
+		TInt temp = aBuddy.iA;
+		aBuddy.iA = iA;
+		iA = temp;
+		}
+	if (aBuddy.iB < iB)
+		{
+		TInt temp = aBuddy.iB;
+		aBuddy.iB = iB;
+		iB = temp;
+		}
+	// if they now overlap, we combine them into one and zero the other
+	if (aBuddy.iB <= iA)
+		iA = aBuddy.iB = aBuddy.iA;
+	else if (aBuddy.iA <= iB)
+		iB = aBuddy.iA = aBuddy.iB;
+	}
+TBool CTextLayout::TRangeChange::IsJoinedTo(const TRangeChange aRange)
+	{
+	TInt a1 = (iA < iB) ? iA : iB;
+	TInt b1 = (iA < iB) ? iB : iA;
+	TInt a2 = (aRange.iA < aRange.iB) ? aRange.iA : aRange.iB;
+	TInt b2 = (aRange.iA < aRange.iB) ? aRange.iB : aRange.iA;
+	return a2 <= b1 && a1 <= b2;
+	}
+void CTextLayout::TRangeChange::Join(const TRangeChange aRange)
+	{
+	TInt a1 = (iA < iB) ? iA : iB;
+	TInt b1 = (iA < iB) ? iB : iA;
+	TInt a2 = (aRange.iA < aRange.iB) ? aRange.iA : aRange.iB;
+	TInt b2 = (aRange.iA < aRange.iB) ? aRange.iB : aRange.iA;
+	// type set to ESet
+	iA = (a1 < a2) ? a1 : a2;
+	iB = (b1 > b2) ? b1 : b2;
+	}
+/** Sets or clears a highlight.
+If the range of characters to highlight is of zero length, the function has no
+effect.
+The function affects only those lines that intersect aDrawRect, which is
+specified in window coordinates. The drawing parameters, including the graphics
+context, are given in aDrawTextLayoutContext.
+From v7.0, this function replaces InvertRangeL().
+This function is not intended to be used to set any part of a highlight already
+set, nor to clear any piece of text not highlighted. It is intended to do
+either or both of: clear an existing selection, set a new selection. See the
+class description for TRangeChange for a code fragment showing how this
+function should be used.
+@param aHighlight Specifies the range of characters to highlight or from which
+to remove the highlight.
+@param aDrawRect Only lines which intersect this rectangle are affected
+(specified in window coordinates).
+@param aDrawTextLayoutContext Provides a graphics context and other drawing
+parameters, e.g. the text and background colours for the highlighted region. */
+EXPORT_C void CTextLayout::Highlight(const CTextLayout::TRangeChange& aChangeHighlight,
+	const TRect& aDrawRect,	const TDrawTextLayoutContext* aDrawTextLayoutContext)
+	{
+	if (!aChangeHighlight.NonNull())
+		return;
+	TRect clip_rect(aDrawRect);
+	CGraphicsContext* gc = aDrawTextLayoutContext->PrimaryGc();
+	if (aDrawTextLayoutContext->UseClippingRect())
+		gc->SetClippingRect(clip_rect);
+	TInt visible_start;
+	TInt visible_length = PosRangeInBand(visible_start);
+	TInt start_pos;
+	TInt end_pos;
+	CTextLayout::TRangeChange::TChangeType type = aChangeHighlight.Get(start_pos, end_pos);
+	start_pos = start_pos < visible_start? visible_start : start_pos;
+	end_pos = end_pos < visible_start + visible_length? end_pos : start_pos + visible_length;
+	TCursorSelection selection(start_pos, end_pos);
+	TPoint top_left = aDrawTextLayoutContext->TopLeftText();
+	top_left.iY -= iBandTop;
+	TBool isDrawingOnAWindowDC = aDrawTextLayoutContext->UseWindowGc();
+	TRect boundingRect;
+	iText->GetUpdateBoundingRect(start_pos, end_pos, top_left, boundingRect);
+	iHighlightExtensions->AbsExtendRect(boundingRect);
+	boundingRect.Intersection(clip_rect);
+	if (! boundingRect.IsEmpty())
+		{
+		if (isDrawingOnAWindowDC)
+			{
+			BeginRedraw(boundingRect);
+			}
+		iText->DrawLayout(*gc, top_left, boundingRect, &aDrawTextLayoutContext->iBackgroundColor, TRUE, &selection, NULL);
+		if (isDrawingOnAWindowDC)
+			{
+			EndRedraw();
+			}
+		}
+	}
+void CTextLayout::HighlightUsingExtensions(const CTextLayout::TRangeChange& aChangeHighlight,const TRangeChange& aFullHighlight,
+	const TRect& aDrawRect,	const TDrawTextLayoutContext* aDrawTextLayoutContext)
+	{
+	if (!aChangeHighlight.NonNull())
+		return;
+	TRect clip_rect(aDrawRect);
+	clip_rect.Intersection(aDrawTextLayoutContext->TextArea());
+	CGraphicsContext* gc = aDrawTextLayoutContext->PrimaryGc();
+	if (aDrawTextLayoutContext->UseClippingRect())
+		{
+		gc->SetClippingRect(clip_rect);
+		}
+	TInt visible_start;
+	TInt visible_length = PosRangeInBand(visible_start);
+	TInt start_pos;
+	TInt end_pos;
+	CTextLayout::TRangeChange::TChangeType type = aChangeHighlight.Get(start_pos, end_pos);
+	start_pos = start_pos < visible_start? visible_start : start_pos;
+	end_pos = end_pos < visible_start + visible_length? end_pos : start_pos + visible_length;
+	TInt full_start_pos;
+	TInt full_end_pos;
+	(void)aFullHighlight.Get(full_start_pos, full_end_pos);
+	full_start_pos = full_start_pos < visible_start? visible_start : full_start_pos;
+	full_end_pos = full_end_pos < visible_start + visible_length? full_end_pos : full_start_pos + visible_length;
+	TCursorSelection selection(full_start_pos, full_end_pos);
+	TPoint top_left = aDrawTextLayoutContext->TopLeftText();
+	top_left.iY -= iBandTop;
+	TBool isDrawingOnAWindowDC = aDrawTextLayoutContext->UseWindowGc();
+	TRect boundingRect;
+	iText->GetUpdateBoundingRect(start_pos, end_pos, top_left, boundingRect);
+	iHighlightExtensions->AbsExtendRect(boundingRect);
+	boundingRect.Intersection(clip_rect);
+	if (! boundingRect.IsEmpty())
+		{
+		if (isDrawingOnAWindowDC)
+			{
+			BeginRedraw(boundingRect);
+			}
+		iText->DrawLayout(*gc, top_left, boundingRect, &aDrawTextLayoutContext->iBackgroundColor, TRUE, &selection, iHighlightExtensions);
+		if (isDrawingOnAWindowDC)
+			{
+			EndRedraw();
+			}
+		}
+	if (aDrawTextLayoutContext->UseClippingRect())
+		{
+		gc->CancelClippingRect();
+		}
+	}
+/** Toggles the selection highlight for the range of text in aHighlight.
+Highlights only those lines that intersect aDrawRect, which is specified in
+window coordinates. The drawing parameters, including the graphics context, are
+given in aDrawTextLayoutContext.
+In v7.0 and onwards, this function is deprecated -Highlight() should be used
+instead.
+@deprecated
+@param aHighlight The range of characters for which to invert the highlighting.
+@param aDrawRect Only lines which intersect this rectangle are affected;
+specified in window coordinates.
+@param aDrawTextLayoutContext Provides a graphics context and other drawing
+parameters. */
+EXPORT_C void CTextLayout::InvertRangeL(const TCursorSelection& aHighlight,const TRect& aDrawRect,
+	const TDrawTextLayoutContext* aDrawTextLayoutContext)
+	{
+	TRangeChange range(aHighlight.iAnchorPos, aHighlight.iCursorPos, TRangeChange::ESet);
+	HighlightUsingExtensions(range,range,aDrawRect,aDrawTextLayoutContext);
+	}
+/**
+Return the FORM major version number. This function is not generally useful. It
+is used in test code and was used while making a transition between this and
+the former version of FORM. The return value is always 2.
+*/
+EXPORT_C TInt CTextLayout::MajorVersion() const
+	{
+	return 2;
+	}
+/**
+This method allows Form clients to register an object able to
+create or return references to customisation objects used within Form for
+various tasks e.g. inline text.
+@param aProvider
+	Reference to interface provider object to register with Formm.
+*/
+EXPORT_C void CTextLayout::SetInterfaceProvider( MFormCustomInterfaceProvider* aProvider )
+{
+iSource->iInterfaceProvider = aProvider;
+}
+/** Gets the width and height of the bounding box of the text, including
+indents and margins, when formatted to the specified wrap width.
+This is useful for applications like a web browser that need to determine the
+minimum width for a piece of text: if you specify zero as the wrap width, the
+returned aSize.iWidth contains the minimum width that could be used for the
+text without illegal line breaks, and if you specify KMaxTInt for aWrapWidth,
+the returned aSize.iHeight contains the minimum height: the height when each
+paragraph is a single line of unlimited length.
+@since 6.0
+@param aWrapWidth The wrap width for the bounding box.
+@param aSize On return, contains the width and height of the bounding box. */
+EXPORT_C void CTextLayout::GetMinimumSizeL(TInt aWrapWidth,TSize& aSize)
+	{
+	//
+	//Get the size of the minimal bounding box of the text when formatted to the specified wrap width.
+	//The width may be greater than aWrapWidth. To find the minimum width for the text,
+	//pass 0 for aWrapWidth. To find the minimum height, pass KMaxTInt for aWrapWidth.
+	//
+	iText->GetMinimumLayoutSizeL(aWrapWidth,aSize);
+	}
+/** Gets the width and height of the bounding box of the text, including
+indents and margins, when formatted to the specified wrap width.
+This is useful for applications like a web browser that need to determine the
+minimum width for a piece of text: if you specify zero as the wrap width, the
+returned aSize.iWidth contains the minimum width that could be used for the
+text, and if you specify KMaxTInt for aWrapWidth, the returned aSize.iHeight
+contains the minimum height: the height when each paragraph is a single
+line of unlimited length. Use aAllowLegalLineBreaksOnly to set whether or
+not illegal line breaks should be considered when determining aSize.
+@since 6.0
+@param aWrapWidth The wrap width for the bounding box.
+@param aAllowLegalLineBreaksOnly ETrue to only allow legal line breaks, or EFalse to also allow illegal line breaks.
+@param aSize On return, contains the width and height of the bounding box. */
+EXPORT_C void CTextLayout::GetMinimumSizeL(TInt aWrapWidth,TBool aAllowLegalLineBreaksOnly,TSize& aSize)
+	{
+	//
+	//Get the size of the minimal bounding box of the text when formatted to the specified wrap width.
+	//The width may be greater than aWrapWidth. To find the minimum width for the text,
+	//pass 0 for aWrapWidth. To find the minimum height, pass KMaxTInt for aWrapWidth.
+	//
+	iText->GetMinimumLayoutSizeL(aWrapWidth,aAllowLegalLineBreaksOnly,aSize);
+	}
+/** Sets the custom drawing object, for customising the way text and its
+background are drawn.
+@since 6.0
+@param aCustomDraw Pointer to a custom drawing object. */
+EXPORT_C void CTextLayout::SetCustomDraw(const MFormCustomDraw* aCustomDraw)
+	{
+	iSource->iCustomDraw = aCustomDraw;
+	}
+/** Returns a pointer to the current custom drawing implementation. Returns
+NULL if custom drawing is not in force.
+@since 6.0
+@return Pointer to the custom drawing object. */
+EXPORT_C const MFormCustomDraw* CTextLayout::CustomDraw() const
+	{
+	return iSource->iCustomDraw;
+	}
+/** Sets custom line breaking.
+If this function is not called, default line breaking behaviour is used.
+Ownership of the custom line breaking object is not transferred to this object.
+@param aCustomWrap A pointer to an object that implements the custom line
+breaking interface. Specify NULL to disable custom line breaking. */
+EXPORT_C void CTextLayout::SetCustomWrap(const MFormCustomWrap* aCustomWrap)
+	{
+	iSource->iCustomWrap = aCustomWrap;
+	}
+/** Gets the custom line breaking object, as set using SetCustomWrap().
+@return A pointer to the custom line breaking object, or NULL if custom line
+breaking is not in effect. */
+EXPORT_C const MFormCustomWrap* CTextLayout::CustomWrap() const
+	{
+	return iSource->iCustomWrap;
+	}
+/**
+@internalAll
+@released
+*/
+EXPORT_C void MFormCustomDraw::MFormCustomDraw_Reserved_2()
+	{
+	}
+/** This function is called whenever part of the background of a CTextLayout or
+CTextView object needs to be drawn. The default implementation fills
+aParam.iDrawRect with the colour specified in aBackground.
+The default background colour is contained in aBackground. This is the
+background colour of the paragraph if drawing text, or the background colour
+specified in the TDrawTextLayoutContext object passed to CTextLayout::DrawL()
+if drawing outside the text area.
+The rectangle which is drawn by this function, (this may not be the whole of
+aParam.iDrawRect) must be returned in aDrawn; areas not drawn by you are
+automatically filled using the colour aBackground.
+@param aParam Contains the drawing parameters: aParam.iGc is the graphics
+context to use. aParam.iMap is the graphics device map, which allows you to
+convert between pixels and twips and create fonts. aParam.iTextLayoutTopLeft is
+the origin of the text; bitmaps and other graphics must be drawn relative to
+this position. aParam.iDrawRect is the area to be drawn; do not draw outside
+this rectangle.
+@param aBackground The default background colour. This is the background colour
+of the paragraph if drawing text, or the background colour specified in the
+TDrawTextLayoutContext object passed to CTextLayout::DrawL() if drawing outside
+the text area.
+@param aDrawn Must return the rectangle you actually draw. This may not be the
+whole of aParam.iDrawRect (for instance, if you are drawing a non-tiled bitmap
+that occupies only part of aRect). */
+EXPORT_C void MFormCustomDraw::DrawBackground(const TParam& aParam,const TRgb& aBackground,TRect& aDrawn) const
+	{
+	MTmCustom c;
+	c.DrawBackground(aParam.iGc,aParam.iTextLayoutTopLeft,aParam.iDrawRect,aBackground,aDrawn);
+	}
+/** This function is called after the background has been drawn by
+DrawBackground(), and before drawing the text. This function might be used to
+draw a ruled line under each line of text.
+The default implementation of this function does nothing.
+@param aParam Contains the drawing parameters. You should only draw to
+aParam.iDrawRect. There is no need to fill aParam.iDrawRect or to indicate the
+rectangle drawn.
+@param aLineInfo Contains the line metrics: aLineInfo.iOuterLineRect specifies
+the bounding rectangle of the line, including margins, indents and automatic
+space above and below paragraphs, aLineInfo.iInnerLineRect specifies the bounds
+of the text only, aLineInfo.iBaseline specifies the baseline of the text. */
+EXPORT_C void MFormCustomDraw::DrawLineGraphics(const TParam& /*aParam*/,const TLineInfo& /*aLineInfo*/) const
+	{
+	// do nothing
+	}
+/** This function is called to draw the text and its highlighted background, if
+any, after bidirectional reordering and other character mappings have taken
+place.
+The default implementation of this function draws the text with no special
+effects and supports standard, round-cornered and shadowed highlighting only.
+The text is drawn with the left end of its baseline located at aTextOrigin
+after drawing the background, if any, in aParam.iDrawRect.
+The main reason to override this function is to apply custom text highlighting,
+(for this, aFormat.iFontPresentation.iHighlightStyle should be in the range
+EFontHighlightFirstCustomStyle to EFontHighlightLastCustomStyle).
+The horizontal spacing between the characters in the text string is increased
+by the number of pixels specified in aExtraPixels. The standard way to do this
+is by calling CGraphicsContext::SetCharJustification().
+The font and other graphics parameters (e.g. pen colour, font style), are
+specified in aParam.iGc but a character format container (aFormat) is supplied
+so that a different font can be used. Note that any graphics drawn cannot
+exceed the bounds of aParam.iDrawRect, so changes are usually restricted to
+drawing shadows, outlines, etc. if custom highlighting is in use.
+@param aParam Contains the drawing parameters. Drawing can only occur within
+aParam.iDrawRect.
+@param aLineInfo Contains the line metrics.
+@param aFormat Specifies the character formatting to apply to the text,
+including the type of text highlighting.
+@param aText The text string to be drawn.
+@param aTextOrigin The point at which the left end of the baseline of the text
+should be drawn.
+@param aExtraPixels The number of additional pixels to insert between the
+characters in the text string, in order to increase its length. */
+EXPORT_C void MFormCustomDraw::DrawText(const TParam& aParam,const TLineInfo& aLineInfo,const TCharFormat& aFormat,
+										const TDesC& aText,const TPoint& aTextOrigin,TInt aExtraPixels) const
+	{
+	TTmLineInfo info;
+	info.iOuterRect = aLineInfo.iOuterRect;
+	info.iInnerRect = aLineInfo.iInnerRect;
+	info.iBaseline = aLineInfo.iBaseline;
+	MTmCustom c;
+	c.DrawText(aParam.iGc,aParam.iTextLayoutTopLeft,aParam.iDrawRect,info,aFormat,
+			   aText,aTextOrigin,aExtraPixels);
+	}
+EXPORT_C void MFormCustomDraw::DrawText(const TParam& aParam,const TLineInfo& aLineInfo,const TCharFormat& aFormat,
+										const TDesC& aText,const TInt aStart, const TInt aEnd, const TPoint& aTextOrigin,TInt aExtraPixels) const
+	{
+	TTmLineInfo info;
+	info.iOuterRect = aLineInfo.iOuterRect;
+	info.iInnerRect = aLineInfo.iInnerRect;
+	info.iBaseline = aLineInfo.iBaseline;
+	MTmCustomExtension c;
+	c.DrawText(aParam.iGc,aParam.iTextLayoutTopLeft,aParam.iDrawRect,info,aFormat,
+			   aText,aStart,aEnd,aTextOrigin,aExtraPixels);
+	}
+/** This function translates logical colours specified in FORM objects into
+real colours. The default implementation just returns the default colour that
+is passed in and ignores aColorIndex.
+Overriding implementations may use aColorIndex in any desired way, either to
+replace or modify aDefaultColor. The values used in aColorIndex are taken from
+the top byte of a TLogicalRgb object and are thus in the range 0...255. The
+TLogicalRgb class defines two reserved values:
+TLogicalRgb::ESystemForegroundIndex = 254 and
+TLogicalRgb::ESystemBackgroundIndex = 255.
+*/
+EXPORT_C TRgb MFormCustomDraw::SystemColor(TUint /*aColorIndex*/,TRgb aDefaultColor) const
+	{
+	return aDefaultColor;
+	}
+void CTextLayout::DrawBackground(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aClipRect,
+								 const TLogicalRgb& aBackground) const
+	{
+	TPoint top_left(aTopLeft);
+	top_left.iY -= iBandTop;
+	iText->DrawBackground(aGc,top_left,aClipRect,aBackground);
+	}
+/** Returns the line break class for a Unicode character.
+For convenience, it also gets the range of consecutive characters (if any)
+according to the Unicode standard, including aCode, that share the same line
+break class.
+The Unicode line break classes are enumerated in class MTmCustom.
+Each character's line break class is obtained using LineBreakClass(). To find
+out whether a line break is allowed between two adjacent characters, call
+LineBreakPossible() with the line break classes of the two characters as
+arguments. For example, the line break class EClLineBreakClass (closing
+punctuation) applies to characters such as ")", "]" and ";". Line breaks are
+typically allowed after these characters, but not before, so a call to
+LineBreakPossible() with the arguments (EAlLineBreakClass, EClLineBreakClass)
+would return EFalse in the default implementation, but a call with
+(EClLineBreakClass, EAlLineBreakClass) would return ETrue.
+@param aCode The Unicode character code of interest.
+@param aRangeStart On return, contains the Unicode character code at the start
+of the range including aCode that shares the same line break class as aCode.
+@param aRangeEnd On return, contains the Unicode character code at the end of
+the range including aCode that shares the same line break class as aCode.
+@return The line break class assigned to the character. Line break classes are
+enumerated in class MTmCustom. */
+EXPORT_C TUint MFormCustomWrap::LineBreakClass(TUint aCode,TUint& aRangeStart,TUint& aRangeEnd) const
+	{
+	// Create an instance of MTmCustom and then call the MTmCustom's functions for getting a Line Break class
+	MTmCustom c;
+	TUint temp;
+	temp=c.LineBreakClass(aCode,aRangeStart,aRangeEnd);
+	return temp;
+	}
+/** Tests whether a line break is possible between two characters.
+If aHaveSpaces is true, the characters are not adjacent one or more space
+characters (with a line break class of ESpLineBreakClass) occur between them.
+The aPrevClass and aNextClass arguments never have the value ESpLineBreakClass.
+Instead, this function is called with the classes of the characters on either
+side of the space or run of spaces, (and if so, aHaveSpaces is true). This is
+so that line breaks can be prohibited between certain characters with
+intervening spaces, for instance an alphabetic character (EAlLineBreakClass,
+such as 'a') and a closing bracket, with a space inbetween.
+Additionally, the arguments to this function never have a value of
+ESaLineBreakClass. For such characters, GetLineBreakInContext() is called
+instead.
+@param aPrevClass The line break class of the previous non-space character.
+@param aNextClass The line break class of the next non-space character.
+@param aHaveSpaces ETrue if there are one or more space characters (with a line
+break class of ESpLineBreakClass) between aPrevClass and aNextClass. EFalse if
+not.
+@return ETrue if a line break is possible between characters with the two line
+break classes, EFalse if not. */
+EXPORT_C TBool MFormCustomWrap::LineBreakPossible(TUint aPrevClass,TUint aNextClass,TBool aHaveSpaces) const
+	{
+	MTmCustom c;
+	TBool temp;
+	temp=c.LineBreakPossible(aPrevClass,aNextClass,aHaveSpaces);
+	return temp;
+	}
+/** Gets the position of the first or last possible line break position in a
+text string.
+This function is called instead of LineBreakPossible() for runs of characters
+of class ESaLineBreakClass. It is used for South Asian languages like Thai, Lao
+and Khmer that have no spaces between words, so that line breaks must be
+calculated using dictionary lookup or a linguistic algorithm.
+The default implementation of this function just returns false.
+@param aText A string containing characters of class ESaLineBreakClass.
+@param aMinBreakPos A position within aText at which to begin searching for a
+possible line break position.
+@param aMaxBreakPos A position within aText at which to stop searching for a
+possible line break position.
+@param aForwards If ETrue, the function gets the first possible line break
+position (searches forwards from aMinBreakPos); if EFalse, gets the last one
+(searches backwards from aMaxBreakPos).
+@param aBreakPos On return, the position of the first or last possible line
+break within aText. This must be greater than zero and less than aText.Length()
+- 1, and must also be in the range aMinBreakPos to aMaxBreakPos.
+@return ETrue if a possible line break position is found, EFalse if not. */
+EXPORT_C TBool MFormCustomWrap::GetLineBreakInContext(const TDesC& aText,TInt aMinBreakPos,TInt aMaxBreakPos,
+													  TBool aForwards,TInt& aBreakPos) const
+	{
+	MTmCustom c;
+	TBool temp;
+	temp=c.GetLineBreakInContext(aText,aMinBreakPos,aMaxBreakPos,aForwards,aBreakPos);
+	return temp;
+	}
+/** Tests whether a character can overhang the right margin.
+This function can be overridden to customise the line breaking behaviour for
+closing punctuation in Japanese. Any characters for which this function returns
+ETrue are allowed to overhang the right margin. The rest will be moved to the
+next line.
+The default implementation of this function just returns false.
+@param aChar The Unicode character code of interest.
+@return ETrue if the character specified can overhang the right margin, EFalse if
+not. */
+EXPORT_C TBool MFormCustomWrap::IsHangingCharacter(TUint aChar) const
+	{
+	MTmCustom c;
+	TBool temp;
+	temp=c.IsHangingCharacter(aChar);
+	return temp;
+	}
+// Reserved functions are private until they are used
+/**
+@internalAll
+@released
+*/
+EXPORT_C void MFormCustomWrap::MFormCustomWrap_Reserved_1()
+	{
+	// reserved functions
+	}
+// Reserved functions are private until they are used.
+/**
+@internalAll
+@released
+*/
+EXPORT_C void MFormCustomWrap::MFormCustomWrap_Reserved_2()
+	{
+	// reserved functions
+	}
+#ifdef _DEBUG
+TBool CTextLayout::__DbgIsFormattingUpToDate() const
+	{
+	return iUnformattedStart == KMaxTInt;
+	}
+#endif
+// TLayDocTextSource stuff begins here.
+TLayDocTextSource::TLayDocTextSource():
+	iLayDoc(NULL),
+	iFlags(EWrap),
+	iWidth(KMaxTInt),
+	iEllipsis(0x2026),
+	iLabelsWidth(0),
+	iLabelsGutter(0),
+	iFormatMode(CLayoutData::EFScreenMode),
+	iImageDevice(NULL),
+	iLabelsDevice(NULL),
+	iFormatDevice(NULL),
+	iFontHeightIncreaseFactor(EDefaultFontHeightIncreaseFactor),
+	iMinimumLineDescent(EDefaultMinimumLineDescent),
+	iNonPrintingCharVisibility(),
+	iFormParam(NULL),
+	iCustomDraw(NULL),
+	iCustomWrap(NULL),
+	iInterfaceProvider(NULL),
+	iDrawOpaque(EFalse),
+	iExcessHeightRequired(0),
+	iInvisibleCharacterRemapper(NULL)
+	{
+	}
+MGraphicsDeviceMap& TLayDocTextSource::FormatDevice() const
+	{
+	if (!iFormatDevice)
+		CTextLayout::Panic(CTextLayout::EFormatDeviceNotSet);
+	if (iLabelsDevice && (iFlags & EUseLabelsDevice))
+		return *iLabelsDevice;
+	else
+		return *iFormatDevice;
+	}
+MGraphicsDeviceMap& TLayDocTextSource::InterpretDevice() const
+	{
+	if (!iImageDevice)
+		CTextLayout::Panic(CTextLayout::EImageDeviceNotSet);
+	if (iLabelsDevice && (iFlags & EUseLabelsDevice))
+		return *iLabelsDevice;
+	else
+		return *iImageDevice;
+	}
+TInt TLayDocTextSource::DocumentLength() const
+	{
+	return iLayDoc->LdDocumentLength();
+	}
+void TLayDocTextSource::GetText(TInt aPos,TPtrC& aText,TTmCharFormat& aFormat) const
+	{
+	TCharFormat f;
+	iLayDoc->GetChars(aText,f,aPos);
+	aFormat = f;
+	}
+void TLayDocTextSource::GetParagraphFormatL(TInt aPos,RTmParFormat& aFormat) const
+	{
+	CParaFormat f;
+	iLayDoc->GetParagraphFormatL(&f,aPos);
+	// Labels should not have a forced line height or borders so remove these (this is necessary for Agenda).
+	if (iFlags & EUseLabelsDevice)
+		{
+		f.iLineSpacingInTwips = 0;
+		f.iLineSpacingControl = CParaFormat::ELineSpacingAtLeastInTwips;
+		f.RemoveAllBorders();
+		}
+	aFormat.CopyL(f);
+	f.Reset();
+	}
+TRgb TLayDocTextSource::SystemColor(TUint aColorIndex,TRgb aDefaultColor) const
+	{
+	if (iCustomDraw)
+		return iCustomDraw->SystemColor(aColorIndex,aDefaultColor);
+	else if (iFormParam)
+		return iFormParam->SystemColor(aColorIndex,aDefaultColor);
+	else
+		return aDefaultColor;
+	}
+CPicture* TLayDocTextSource::PictureL(TInt aPos) const
+	{
+	return iLayDoc->PictureHandleL(aPos,MLayDoc::EForceLoadTrue);
+	}
+TInt TLayDocTextSource::GetPictureSizeInTwipsL(TInt aPos,TSize& aSize) const
+	{
+	return iLayDoc->GetPictureSizeInTwips(aSize,aPos);
+	}
+TInt TLayDocTextSource::ParagraphStart(TInt aPos) const
+	{
+	iLayDoc->LdToParagraphStart(aPos);
+	return aPos;
+	}
+TBool TLayDocTextSource::LabelModeSelect(TLabelType aType, TInt aPos)
+	{
+	if (!(iFlags & EUseLabelsDevice) && aType == EParLabel)
+		{
+		// Labels are not allowed on zero-length documents;
+		// this is required for Agenda (see ER5U defect EDNGASR-482LSF).
+		if (iLayDoc->LdDocumentLength() == 0)
+			return FALSE;
+		if (iLayDoc->SelectParagraphLabel(aPos))
+			{
+			iFlags |= EUseLabelsDevice;
+			return TRUE;
+			}
+		}
+	return FALSE;
+	}
+void TLayDocTextSource::LabelMetrics(TLabelType aType, TSize& aLabelSize, TInt& aMarginSize) const
+	{
+	if (aType == EParLabel)
+		{
+		aLabelSize.iWidth = iLabelsWidth;
+		aLabelSize.iHeight = KMaxTInt;
+		aMarginSize = iLabelsWidth + iLabelsGutter;
+		}
+	else
+		{
+		aLabelSize.iWidth = 0;
+		aLabelSize.iHeight = 0;
+		aMarginSize = 0;
+		}
+	}
+void TLayDocTextSource::LabelModeCancel()
+	{
+	iLayDoc->CancelSelectLabel();
+	iFlags &= ~EUseLabelsDevice;
+	}
+/**
+This method is responsible for discovering interface extension objects
+requried by Form for the specified interface Uid.
+@param aInterfaceId
+	Identifier for the optional interface requried.
+@return
+	Pointer to object supporting the requested interface,
+	or 0 if not supported.
+*/
+TAny* TLayDocTextSource::GetExtendedInterface(const TUid& aInterfaceId)
+	{
+	TAny* interfacePtr = 0;
+	// First check to see if their is an external interface provider
+	// registered and ask it for the interface.
+	if (iInterfaceProvider)
+		{
+		interfacePtr = iInterfaceProvider->GetExtendedInterface( aInterfaceId );
+		}
+	// If interface still not supplied check self and parent to provide it
+	if (!interfacePtr)
+		{
+		if (aInterfaceId == KFormLabelApiExtensionUid)
+			{
+			return static_cast<MFormLabelApi*>(this);
+			}
+		else if(aInterfaceId == KTmTextDrawExtId)
+			{
+			return static_cast <MTmTextDrawExt*> (this);
+			}
+		else if(aInterfaceId == KTmCustomExtensionUid)
+			{
+			return static_cast <MTmCustomExtension*> (this);
+			}
+		else
+			{
+			// In this instance, calling the parent class will always return NULL
+			// but the pattern should be followed by all implementors for safety
+			return MTmSource::GetExtendedInterface(aInterfaceId);
+			}
+		}
+	// Return the interface object or 0 if not supported.
+	return interfacePtr;
+	}
+void TLayDocTextSource::SetLineHeight(const TLineHeightParam& aParam,TInt& aAscent,TInt& aDescent) const
+	{
+	// Increase the ascent by the font height increase percentage.
+	TLineHeightParam p = aParam;
+	p.iFontMaxAscent += ((p.iFontMaxAscent + p.iFontMaxDescent) * iFontHeightIncreaseFactor) / 100;
+	// Call the standard SetLineHeight.
+	MTmSource::SetLineHeight(p,aAscent,aDescent);
+	// iExcessHeightRequired is used when height of the highest glyph can be
+	// greater than CFont::AscentInPixels() and in iExactLineSpacing mode
+	// This value is set via CTextView::SetExcessHeightRequired()
+	if ( aParam.iExactLineHeight )
+		{
+		aAscent += iExcessHeightRequired;
+		aDescent -= iExcessHeightRequired;
+	}
+	// Enforce the minimum descent; the following logic is borrowed from CLineLayout::WrapLineL in old FORM.
+	if (aAscent + aDescent <= iMinimumLineDescent && aDescent == 0)
+		{
+		aDescent = 1;
+		aAscent--;
+		}
+	else if (aDescent < iMinimumLineDescent)
+		aDescent = iMinimumLineDescent;
+	/*
+	Ensure the line is at least 1 pixel high and ascent and descent are non-negative so that assertion
+	TCursorPosition::GetLineRectL that cursor pos is contained in line rect doesn't fire.
+	*/
+	if (aAscent < 0)
+		aAscent = 0;
+	if (aDescent < 0)
+		aDescent = 0;
+	if (aAscent + aDescent == 0)
+		aDescent = 1;
+	}
+TBool TLayDocTextSource::CanMap() const
+	{
+	return iFormatMode == CLayoutData::EFScreenMode || iFormatMode == CLayoutData::EFWysiwygMode;
+	}
+TBool TLayDocTextSource::PageBreakInRange(TInt aStartPos,TInt aEndPos) const
+	{
+	if (CanMap() && iNonPrintingCharVisibility.PageBreaksVisible())
+		return iLayDoc->EnquirePageBreak(aStartPos,aEndPos - aStartPos);
+	else
+		return FALSE;
+	}
+void TLayDocTextSource::DrawBackground(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aRect,
+									   const TLogicalRgb& aBackground,TRect& aDrawn) const
+	{
+	ResetOpaque(aGc);
+	if (iCustomDraw)
+		{
+		MFormCustomDraw::TParam param(aGc,InterpretDevice(),aTopLeft,aRect);
+		TLogicalRgb background = aBackground;
+		FormUtil::LogicalToActualColor(iFormParam,background);
+		iCustomDraw->DrawBackground(param,background,aDrawn);
+		}
+	else
+		MTmSource::DrawBackground(aGc,aTopLeft,aRect,aBackground,aDrawn);
+	}
+void TLayDocTextSource::DrawLineGraphics(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aRect,
+										 const TTmLineInfo& aLineInfo) const
+	{
+	SetOpaque(aGc);
+	if (iCustomDraw)
+		{
+		MFormCustomDraw::TParam param(aGc,InterpretDevice(),aTopLeft,aRect);
+		MFormCustomDraw::TLineInfo lineinfo(aLineInfo.iOuterRect,aLineInfo.iInnerRect,aLineInfo.iBaseline);
+		iCustomDraw->DrawLineGraphics(param,lineinfo);
+		}
+	else
+		MTmSource::DrawLineGraphics(aGc,aTopLeft,aRect,aLineInfo);
+	ResetOpaque(aGc);
+	}
+void TLayDocTextSource::DrawText(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aRect,
+								 const TTmLineInfo& aLineInfo,const TTmCharFormat& aFormat,
+								 const TDesC& aText,const TPoint& aTextOrigin,TInt aExtraPixels) const
+	{
+	SetOpaque(aGc);
+	if (iCustomDraw)
+		{
+		MFormCustomDraw::TParam param(aGc,InterpretDevice(),aTopLeft,aRect);
+		MFormCustomDraw::TLineInfo lineinfo(aLineInfo.iOuterRect,aLineInfo.iInnerRect,aLineInfo.iBaseline);
+		TCharFormat f;
+		aFormat.GetTCharFormat(f);
+		iCustomDraw->DrawText(param,lineinfo,f,aText,aTextOrigin,aExtraPixels);
+		}
+	else
+		MTmSource::DrawText(aGc,aTopLeft,aRect,aLineInfo,aFormat,aText,aTextOrigin,aExtraPixels);
+	ResetOpaque(aGc);
+	}
+void TLayDocTextSource::DrawText(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aRect,
+								 const TTmLineInfo& aLineInfo,const TTmCharFormat& aFormat,
+								 const TDesC& aText,const TInt aStart, const TInt aEnd, const TPoint& aTextOrigin,TInt aExtraPixels) const
+	{
+	SetOpaque(aGc);
+	if (iCustomDraw)
+		{
+		MFormCustomDraw::TParam param(aGc,InterpretDevice(),aTopLeft,aRect);
+		MFormCustomDraw::TLineInfo lineinfo(aLineInfo.iOuterRect,aLineInfo.iInnerRect,aLineInfo.iBaseline);
+		TCharFormat f;
+		aFormat.GetTCharFormat(f);
+		iCustomDraw->DrawText(param,lineinfo,f,aText,aStart,aEnd,aTextOrigin,aExtraPixels);
+		}
+	else
+		MTmCustomExtension::DrawText(aGc,aTopLeft,aRect,aLineInfo,aFormat,aText,aStart,aEnd,aTextOrigin,aExtraPixels);
+	ResetOpaque(aGc);
+	}
+TBool TLayDocTextSource::LineBreakPossible(TUint aPrevClass,TUint aNextClass,TBool aHaveSpaces) const
+	{
+	TBool temp;
+	if (iCustomWrap)
+		temp=iCustomWrap->LineBreakPossible(aPrevClass,aNextClass,aHaveSpaces);
+	else
+		temp=MTmSource::LineBreakPossible(aPrevClass,aNextClass,aHaveSpaces);
+	return temp;
+	}
+TUint TLayDocTextSource::LineBreakClass(TUint aCode,TUint& aRangeStart,TUint& aRangeEnd) const
+	{
+	TUint temp;
+	if (iCustomWrap)
+		temp=iCustomWrap->LineBreakClass(aCode,aRangeStart,aRangeEnd);
+	else
+		temp=MTmSource::LineBreakClass(aCode,aRangeStart,aRangeEnd);
+	return temp;
+	}
+TBool TLayDocTextSource::GetLineBreakInContext(const TDesC& aText,TInt aMinBreakPos,TInt aMaxBreakPos,
+												 TBool aForwards,TInt& aBreakPos) const
+	{
+	TBool temp;
+	if (iCustomWrap)
+		temp=iCustomWrap->GetLineBreakInContext(aText,aMinBreakPos,aMaxBreakPos,aForwards,aBreakPos);
+	else
+		temp=MTmSource::GetLineBreakInContext(aText,aMinBreakPos,aMaxBreakPos,aForwards,aBreakPos);
+	return temp;
+	}
+TBool TLayDocTextSource::IsHangingCharacter(TUint aChar) const
+	{
+	TBool temp;
+	if (iCustomWrap)
+		temp=iCustomWrap->IsHangingCharacter(aChar);
+	else
+		temp=MTmSource::IsHangingCharacter(aChar);
+	return temp;
+	}
+TUint TLayDocTextSource::Map(TUint aChar) const
+	{
+	// Check if custom formatting has been installed
+	if (iInvisibleCharacterRemapper)
+		{ // Then use the supplied custom invisible character remapping
+		return iInvisibleCharacterRemapper->Remap(aChar, iNonPrintingCharVisibility, *this);
+		}
+	else // Use the default
+		return MFormCustomInvisibleCharacterRemapper::DefaultMapping(aChar, iNonPrintingCharVisibility, *this);
+	}
+void TLayDocTextSource::DrawPicture(CGraphicsContext& aGc,
+									const TPoint& aTextLayoutTopLeft, const TRect& aRect,
+									MGraphicsDeviceMap& aDevice, const CPicture& aPicture) const
+	{
+	SetOpaque(aGc);
+	MTmSource::DrawPicture(aGc, aTextLayoutTopLeft, aRect, aDevice, aPicture);
+	ResetOpaque(aGc);
+	}
+//MTmTextDrawExt implementations
+/**
+Draws a line. Implements MTmTextDrawExt::DrawLine().
+If the opaque drawing mode is active, then the line color will stay unchanged (it will not be
+alpha-blended in a case of a transparent window).
+@param aGc A reference to a graphics context. If the drawing mode is opaque, then this is a
+CWindowGc reference.
+@param aPt1 Line start point
+@param aPt2 Line end point
+*/
+void TLayDocTextSource::DrawLine(CGraphicsContext& aGc, const TPoint& aPt1, const TPoint& aPt2) const
+	{
+	SetOpaque(aGc);
+	aGc.DrawLine(aPt1, aPt2);
+	ResetOpaque(aGc);
+	}
+/**
+Draws a text. Implements MTmTextDrawExt::DrawText().
+If the opaque drawing mode is active, then the text color will stay unchanged (it will not be
+alpha-blended in a case of a transparent window).
+@param aGc A reference to a graphics context. If the drawing mode is opaqe, then this is a
+CWindowGc reference.
+@param aPt1 Text start point
+*/
+void TLayDocTextSource::DrawText(CGraphicsContext& aGc, const TDesC& aText, const TPoint& aPt) const
+	{
+	SetOpaque(aGc);
+	aGc.DrawText(aText, aPt);
+	ResetOpaque(aGc);
+	}
+/**
+Draws a rectangle. Implements MTmTextDrawExt::DrawRect().
+If the opaque drawing mode is active, then the rectabgle color will stay unchanged (it will not be
+alpha-blended in a case of a transparent window).
+@param aGc A reference to a graphics context. If the drawing mode is opaqe, then this is a
+CWindowGc reference.
+@param aRc Rectangle coordinates
+*/
+void TLayDocTextSource::DrawRect(CGraphicsContext& aGc, const TRect& aRc) const
+	{
+	SetOpaque(aGc);
+	aGc.DrawRect(aRc);
+	ResetOpaque(aGc);
+	}
+/**
+Sets opaque drawing mode.
+@param aGc A reference to a graphics context. If the drawing mode is opaqe, then this is a
+CWindowGc reference.
+*/
+void TLayDocTextSource::SetOpaque(CGraphicsContext& aGc) const
+	{
+	if(iDrawOpaque)
+		{
+		static_cast <CWindowGc&> (aGc).SetOpaque(ETrue);
+		}
+	}
+/**
+Resets opaque drawing mode.
+@param aGc A reference to a graphics context. If the drawing mode is opaqe, then this is a
+CWindowGc reference.
+*/
+void TLayDocTextSource::ResetOpaque(CGraphicsContext& aGc) const
+	{
+	if(iDrawOpaque)
+		{
+		static_cast <CWindowGc&> (aGc).SetOpaque(EFalse);
+		}
+	}
+// Private CTextLayout functions start here.
+void CTextLayout::Panic(TPanicNumber aNumber)
+	{
+	_LIT(KPanicNumber,"CTextLayout using TAGMA");
+	User::Panic(KPanicNumber,aNumber);
+	}
+void CTextLayout::GetParagraphRect(const TTmDocPos& aDocPos,TRect& aRect) const
+	{
+	aRect.SetRect(0,0,0,0);
+	TTmLineInfo info, info2;
+	if (!iText->DocPosToLine(aDocPos,info))
+		return;
+	aRect = info.iOuterRect;
+	if (!(info.iFlags & TTmLineInfo::EParStart))
+		{
+		iText->ParNumberToLine(info.iParNumber,0,info2);
+		aRect.iTl = info2.iOuterRect.iTl;
+		}
+	if (!(info.iFlags & TTmLineInfo::EParEnd))
+		{
+		iText->ParNumberToLine(info.iParNumber,KMaxTInt,info2);
+		aRect.iBr = info2.iOuterRect.iBr;
+		}
+	aRect.Move(0,-iBandTop);
+	}
+/**
+Scroll aDy pixels (positive = text moves down); return number of pixels
+actually scrolled. Create a new formatted band if necessary.
+*/
+TInt CTextLayout::ScrollL(TInt aDy,TAllowDisallow aScrollBlankSpace,
+TBool aTopNoLimitBorder/*=EFalse*/,
+TBool aBottomNoLimitBorder/*=EFalse*/)
+	{
+	if ( EFDisallowScrollingBlankSpace == aScrollBlankSpace )
+	    {
+	    aTopNoLimitBorder = EFalse;
+	    aBottomNoLimitBorder = EFalse;
+	    }
+	int old_bandtop = iBandTop;
+	int desired_bandtop = iBandTop - aDy;
+	int pixels_scrolled = 0;
+	int height_increase = 0;
+	int paragraphs_increase = 0;
+	TTmFormatParamBase param;
+	InitFormatParam(param);
+	// Refuse to scroll if the width is illegal. This prevents
+	// time being taken in certain situations where it does
+	// not matter. Once the formatting is capable of
+	// adding smaller chunks of text at a time, this early-out
+	// should become unnecessary.
+	if ((param.iWrapWidth < 1 || param.iMaxHeight < 1)
+		&& param.iFlags & TTmFormatParamBase::EWrap)
+		return 0;
+	param.iMaxHeight = KMaxTInt;
+	int visible_height = VisibleHeightInPixels();
+	if (aDy > 0)		// text moves down; iBandTop decreases
+		{
+		if (aTopNoLimitBorder)
+	        iBandTop = desired_bandtop;
+		else
+		    iBandTop = Max(0,desired_bandtop);//Disallow text scrolled beyond top border
+		pixels_scrolled = old_bandtop - iBandTop;
+		while (pixels_scrolled < aDy)
+			{
+			if (!iText->AddParL(param,TRUE,height_increase,paragraphs_increase))
+				break;
+			pixels_scrolled += height_increase;
+			}
+		if (pixels_scrolled > aDy)
+			{
+			iBandTop = pixels_scrolled - aDy;
+			pixels_scrolled = aDy;
+			}
+		}
+	else if (aDy < 0)	// text moves up; iBandTop increases
+		{
+if (aBottomNoLimitBorder)
+iBandTop = desired_bandtop;
+else
+iBandTop = Min(iText->LayoutHeight(),desired_bandtop);//Disallow text scrolled beyond bottom border
+		pixels_scrolled = old_bandtop - iBandTop;
+		while (pixels_scrolled > aDy)
+			{
+			if (!AddFormattingAtEndL(param, height_increase,paragraphs_increase))
+				break;
+			pixels_scrolled -= height_increase;
+			if (pixels_scrolled < aDy)
+				{
+				height_increase -= aDy - pixels_scrolled;
+				pixels_scrolled = aDy;
+				}
+			iBandTop += height_increase;
+			}
+		// Fill in missing part of visible height.
+		while (iText->LayoutHeight() - iBandTop < visible_height)
+			{
+			if (!AddFormattingAtEndL(param, height_increase,paragraphs_increase))
+				break;
+			}
+		}
+	// Scroll blank space off the display if desired.
+	if (aScrollBlankSpace == EFDisallowScrollingBlankSpace && iText->LayoutHeight() - iBandTop < visible_height)
+		{
+		int new_bandtop = iText->LayoutHeight() - visible_height;
+		if (new_bandtop < 0)
+			new_bandtop = 0;
+		pixels_scrolled += iBandTop - new_bandtop;
+		iBandTop = new_bandtop;
+		}
+	PruneFormatL(aDy < 0);
+	return pixels_scrolled + SetBandTop();
+	}
+TInt CTextLayout::ScrollDocPosIntoViewL(const TTmDocPos& aDocPos)
+	{
+	__ASSERT_DEBUG(aDocPos.iPos <= iText->Source()->DocumentLength(),
+		Panic(EInvalidDocPos));
+	TTmLineInfo info;
+	ExtendFormattingToCoverPosL(aDocPos.iPos);
+	if (!iText->DocPosToLine(aDocPos,info))
+		{
+		__ASSERT_DEBUG(iText->Source()->DocumentLength() == 0,
+			Panic(ECharacterNotFormatted));
+		return ScrollL(iBandTop, EFDisallowScrollingBlankSpace);
+		}
+	TRect line_rect = info.iOuterRect;
+	line_rect.Move(0,-iBandTop);
+	int visible_height = VisibleHeightInPixels();
+	// if the line is taller than the screen, we must not scroll the
+	// baseline off the screen.
+	if (visible_height < info.iBaseline - info.iOuterRect.iTl.iY)
+		return ScrollL(iBandTop + visible_height - info.iBaseline,
+			EFDisallowScrollingBlankSpace);
+	if (line_rect.iTl.iY < 0)
+		return ScrollL(-line_rect.iTl.iY, EFDisallowScrollingBlankSpace);
+	if (line_rect.iBr.iY > visible_height)
+		{
+		int available = line_rect.iTl.iY;
+		int desired = line_rect.iBr.iY - visible_height;
+		if (available > 0)
+			return ScrollL(-Min(desired,available), EFDisallowScrollingBlankSpace);
+		}
+	return 0;
+	}
+EXPORT_C TInt CTextLayout::GetLineNumber(TInt aDocPos)
+	{
+	TTmLineInfo info;
+	TTmDocPos pos(aDocPos,TRUE);
+	if (iText->DocPosToLine(pos,info))
+		return info.iLineNumber;
+	return 0;
+	};
+/*
+Prune the formatted band, if not formatting all the text, to the required size. If aFromStart is ETrue
+prune from the start, otherwise prune from the end.
+*/
+void CTextLayout::PruneFormatL(TBool aFromStart)
+	{
+	if (IsFormattingBand())
+		{
+		int pixels_to_prune = 0;
+		if (aFromStart)
+			pixels_to_prune = iBandTop;
+		else
+			pixels_to_prune = iText->LayoutHeight() - iBandTop - BandHeightInPixels();
+		if (pixels_to_prune <= 0)
+			return;
+		TTmFormatParamBase param;
+		InitFormatParam(param);
+		int height_decrease = 0;
+		if(aFromStart)
+			{
+			while (pixels_to_prune > 0 && iText->DeletePar(param,aFromStart,pixels_to_prune,height_decrease))
+				{
+				pixels_to_prune -= height_decrease;
+				if (aFromStart)
+					iBandTop -= height_decrease;
+				}
+			}
+		else
+			{
+			if (pixels_to_prune > (iBandHeight/2))
+				{
+				iText->DeleteFormattingFromEndL(param,pixels_to_prune,height_decrease);
+				}
+			}
+		}
+	}
+/** Sets the hotspot.
+@param aHotSpot Which part of the line (top, baseline or bottom) should appear
+at a vertical pixel position. */
+EXPORT_C void TViewYPosQualifier::SetHotSpot(TPartOfLine aHotSpot)
+	{
+	iHotSpot = aHotSpot;
+	}
+/** Sets whether blank space should be allowed at the bottom of the view. This
+applies if the document is more than one page long and the last line is
+visible.
+@param aFillScreen ETrue (the default) tries to fill the screen, by ensuring
+that there is as little blank space as possible at the bottom of the view.
+EFalse allows blank space at the bottom. */
+EXPORT_C void TViewYPosQualifier::SetFillScreen(TBool aFillScreen)
+	{
+	iFillScreen = aFillScreen;
+	}
+/** Forces the top line in the view to become fully visible if it is partially
+above the top of the view rectangle.
+@param aMakeLineFullyVisible EFViewForceLineFullyVisible (the default) forces
+the top line to be fully visible EFViewDontForceLineFullyVisible does not. */
+EXPORT_C void TViewYPosQualifier::SetMakeLineFullyVisible(TFullyVisible aMakeLineFullyVisible)
+	{
+	iFullyVisible = aMakeLineFullyVisible;
+	}
+void CTextLayout::InitFormatParam(TTmFormatParamBase& aParam)
+	{
+	aParam.iMaxHeight = BandHeightInPixels();
+	iSource->iExcessHeightRequired = iExcessHeightRequired;
+	aParam.iFlags = TTmFormatParamBase::EAtLeastMaxHeight;
+	aParam.iWrapWidth = iSource->iWidth;
+	if (iSource->iFlags & TLayDocTextSource::EWrap)
+		aParam.iFlags |= TTmFormatParamBase::EWrap;
+	if (iSource->iFlags & TLayDocTextSource::ETruncateWithEllipsis)
+		{
+		aParam.iFlags |= TTmFormatParamBase::ETruncateWithEllipsis;
+		aParam.iEllipsis = iSource->iEllipsis;
+		}
+	}
+TInt CTextLayout::VisibleHeightInPixels() const
+	{
+	if (iSource->iFormatMode == CLayoutData::EFScreenMode || iSource->iFormatMode == CLayoutData::EFWysiwygMode)
+		return iVisibleHeight;
+	else
+		return iSource->InterpretDevice().VerticalTwipsToPixels(iVisibleHeight);
+	}
+TInt CTextLayout::BandHeightInPixels() const
+	{
+	if (iBandHeight == CLayoutData::EFHeightForFormattingAllText)
+		return CLayoutData::EFHeightForFormattingAllText;
+	else
+		return VisibleHeightInPixels();
+	}
+/**
+Sets offsets for the edges of the selection highlight.
+@param aLeftExtension
+	Number of pixels to move the left edge of the highlight to the left.
+@param aRightExtension
+	Number of pixels to move the right edge of the highlight to the right.
+@param aTopExtension
+	Number of pixels to move the top edge of the highlight to up.
+@param aBottomExtension
+	Number of pixels to move the bottom edge of the highlight down.
+*/
+EXPORT_C void CTextLayout::SetHighlightExtensions(TInt aLeftExtension,
+	TInt aRightExtension, TInt aTopExtension, TInt aBottomExtension)
+	{
+	iHighlightExtensions->SetLeftExtension(aLeftExtension);
+	iHighlightExtensions->SetRightExtension(aRightExtension);
+	iHighlightExtensions->SetTopExtension(aTopExtension);
+	iHighlightExtensions->SetBottomExtension(aBottomExtension);
+	}
+/**
+Set the delta required to position the baseline so there is enough
+space for the highset glyph in pixels.  This is the height of the highest glyph -
+CFont::AscentInPixels().  Only used when using TLineSpacingControl::EAttLineSpacingControl.
+By default zero.
+@param aExcessHeightRequired
+	Extra height above CFont::AscentInPixels() required for the highest glyph in pixels.
+*/
+void CTextLayout::SetExcessHeightRequired(TInt aExcessHeightRequired)
+	{
+	iExcessHeightRequired = aExcessHeightRequired;
+	}
+/**
+For any rectangle, aRect, which may be extended, calculate
+the "remainder" rectanges when the view rectangle is intersected with the
+extended rect and then subtracted.
+The remainder rectangles are returned via aRemainderRects, which is required
+to be a pointer to an array of 4 TRect's.
+aRemainderRects[0] is top remainder, ...[1] is bottom, ...[2] is left, ...[3] is right
+*/
+void CTextLayout::GetHighlightRemnants(const TRect& aRect, const TDrawTextLayoutContext& aDrawTextLayoutContext,
+									   TRect* aRemainderRects) const
+	{
+	ASSERT(aRemainderRects);
+	/*
+	overlap is the portion of the view rect that aRect intersects with
+	subtract this from the aRect, giving 4 non-overlapping remainder rectangles,
+	aRemainderRects, any or all of which may be empty. Copied from SubtractRect in TAGMA
+	*/
+	TRect overlap(aDrawTextLayoutContext.iViewRect);
+	overlap.Intersection(aRect);
+	if (overlap.IsEmpty())
+		overlap.SetRect(aRect.iTl,aRect.iTl);
+	aRemainderRects[0] = aRect;
+	aRemainderRects[0].iBr.iY = overlap.iTl.iY;
+	aRemainderRects[1] = aRect;
+	aRemainderRects[1].iTl.iY = overlap.iBr.iY;
+	aRemainderRects[2] = overlap;
+	aRemainderRects[2].iTl.iX = aRect.iTl.iX;
+	aRemainderRects[2].iBr.iX = overlap.iTl.iX;
+	aRemainderRects[3] = overlap;
+	aRemainderRects[3].iTl.iX = overlap.iBr.iX;
+	aRemainderRects[3].iBr.iX = aRect.iBr.iX;
+	}
+/**
+Cleanup method for the opaque flag.
+*/
+void CTextLayout::ResetOpaque(void* aThis)
+	{
+	ASSERT(aThis != NULL);
+	CTextLayout* p = reinterpret_cast <CTextLayout*> (aThis);
+	p->iSource->iDrawOpaque = EFalse;
+	}
+/**
+Sets opaque drawing flag for CTextLayout object. It will used later when the
+content/background has to be drawn.
+Until the flag is not reseted, the opaque drawing will be used
+for all the content except the background - the flag has an useful meaning only for transparent
+editors.
+A TCleanupItem object will be pushed into the Cleanup Stack, which will reset the opaque
+flag durring its destruction.
+*/
+void CTextLayout::SetOpaqueLC()
+	{
+	iSource->iDrawOpaque = ETrue;
+	CleanupStack::PushL(TCleanupItem(&CTextLayout::ResetOpaque, this));
+	}
+void FormPanic(TFormPanic aPanic)
+	{
+	_LIT(KFormPanic,"Form");
+	User::Panic(KFormPanic,aPanic);
+	}
+/**
+Default implementation of mapping invisible character to its specified alternate.
+Called by TLayDocTextSource::Map() unless overidden by custom mapping class.
+May be called by custom mapping class
+@param aChar
+	Invisible character to be remapped
+@param aNonPrintingCharVisibility
+	Current state of flags showing visibility of invisible characters
+@param aLayDoc
+	Const ref to the calling CLayDocTextSource
+@return
+	The replacement character if remapping has taken place, else return original character
+*/
+EXPORT_C TUint MFormCustomInvisibleCharacterRemapper::DefaultMapping( TUint aChar, const TNonPrintingCharVisibility aNonPrintingCharVisibility, const TLayDocTextSource& aLayDoc )
+	{
+	// If mapping special characters is possible, use the specified flags.
+	if (!aNonPrintingCharVisibility.NoneVisible() && aLayDoc.CanMap())
+		{
+		switch (aChar)
+			{
+			case CEditableText::EParagraphDelimiter:
+				if (aNonPrintingCharVisibility.ParagraphDelimitersVisible())
+					return KVisibleParagraphBreak;
+				break;
+			case CEditableText::ELineBreak:
+				if (aNonPrintingCharVisibility.LineBreaksVisible())
+					return KVisibleLineBreak;
+				break;
+			case CEditableText::ENonBreakingSpace:
+				if (aNonPrintingCharVisibility.NonBreakingSpacesVisible())
+					return KVisibleNonBreakSpace;
+				break;
+			case CEditableText::EPotentialHyphen:
+				if (aNonPrintingCharVisibility.PotentialHyphensVisible())
+					return KVisiblePotentialHyphen;
+				break;
+			case CEditableText::ENonBreakingHyphen:
+				if (aNonPrintingCharVisibility.NonBreakingHyphensVisible())
+					return KVisibleNonBreakHyphen;
+				break;
+			case CEditableText::ETabCharacter:
+				if (aNonPrintingCharVisibility.TabsVisible())
+					return KVisibleTab;
+				break;
+			case CEditableText::EPictureCharacter:
+				return KVisiblePicture;
+case 0x200B:    // Zero Width Space: the same behaviour as 0x20, while different category from 0x20.
+if (aNonPrintingCharVisibility.SpacesVisible())
+return KVisibleSpace;
+break;
+			/*
+			For the moment, treat bidirectional controls as if they were non-break spaces, as far as visibility is
+			concerned, and map as follows: LRE=<, RLE=>, PDF=currency symbol, LRO=left guillemet, RLO=right guillemet.
+			*/
+			case 0x202A: // LRE
+				if (aNonPrintingCharVisibility.NonBreakingSpacesVisible())
+					return 0x003C;
+				break;
+			case 0x202B: // RLE
+				if (aNonPrintingCharVisibility.NonBreakingSpacesVisible())
+					return 0x003E;
+				break;
+			case 0x202C: // PDF
+				if (aNonPrintingCharVisibility.NonBreakingSpacesVisible())
+					return 0x00A4;
+				break;
+			case 0x202D: // LRO
+				if (aNonPrintingCharVisibility.NonBreakingSpacesVisible())
+					return 0x00AB;
+				break;
+			case 0x202E: // RLO
+				if (aNonPrintingCharVisibility.NonBreakingSpacesVisible())
+					return 0x00BB;
+				break;
+			default:
+				if (aNonPrintingCharVisibility.SpacesVisible() && TChar(aChar).GetCategory() == TChar::EZsCategory)
+					return KVisibleSpace;
+				break;
+			}
+		}
+	// If not mapping special characters, or not mapping this particular character, use the default mapping.
+	return aLayDoc.MTmSource::Map(aChar);
+	}
+/**
+Allows Form clients to register an invisible character remapper object to
+customize the visible display of invisible characters such as paragraph marks.
+@param aInvisibleCharacterRemapper
+	Pointer to custom invisible character remapper to use
+*/
+EXPORT_C void CTextLayout::SetCustomInvisibleCharacterRemapper( MFormCustomInvisibleCharacterRemapper* aInvisibleCharacterRemapper )
+	{
+	iSource->iInvisibleCharacterRemapper = aInvisibleCharacterRemapper;
+	}
+/**
+Allows Form clients to see which character remapper object is currently
+registered.
+*/
+EXPORT_C MFormCustomInvisibleCharacterRemapper* CTextLayout::GetCustomInvisibleCharacterRemapper()
+	{
+	return iSource->iInvisibleCharacterRemapper;
+	}
+/** INC092568: CTextView::SetPendingSelection is not honoured
+Sets the cursor position member added for this fix that allows the text layout object
+to access any pending selection made by the owning text view object
+@param aPos:- pointer to the owning textview's iCursorPos
+*/
+void CTextLayout::SetTextViewCursorPos(TCursorPosition* aPos)
+	{
+	iTextViewCursorPos = aPos;
+	}
+/**
+This is the function used by CTextLayout when it wants to extend the formatted range downwards.
+It just calls CTmTextLayout::AddParL, but restricts the maximum height of the new formatting to the
+band height/2. If the next paragraph is bigger than this, AddParL will only format part of that
+paragraph, and the formatting will end in the middle of the paragraph.
+*/
+TBool CTextLayout::AddFormattingAtEndL(TTmFormatParamBase& aFormatParam, TInt& aHeightIncrease, TInt& aParagraphsIncrease)
+	{
+	aFormatParam.iMaxHeight = iBandHeight/2;
+	return iText->AddParL(aFormatParam, EFalse, aHeightIncrease, aParagraphsIncrease);
+	}
+/**
+Stops or allows text to be drawn.  Included to allow users to control visibility
+if text is part of an invisible control.
+@param aVisible		ETrue to make the text visible, EFalse to make it invisible.
+@see CCoeControl::MakeVisible()
+*/
+EXPORT_C void CTextLayout::MakeVisible(TBool aVisible)
+	{
+	iText->MakeVisible(aVisible);
+	}

changeset 32	8b9155204a54
child 44	601ab138ba0b