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

equal deleted inserted replaced

-:f902e87c146f
+:748ec5531811
 #include "FRMCONST_PARTNER.H"
 #include "TAGMA_INTERNAL.H"
 #include "FRMTLAY_INTERNAL.H"
 #endif
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "LAYEMUTraces.h"
+#endif
 const TInt KMaxExtraLines = 10; // maximum number of lines to format after the current and following lines
 								// before using background formatting
 // during page down/up, the number of lines that should remain visible after
 // the scroll, counting from the first line that is not completely visible.
 // i.e. setting this to 0 means always scroll KMaxProportionOfScreenToScroll.
 const TInt KMaxProportionOfScreenToScroll = 1000;
 /** minimum scroll proportions in thousandths. This overrides
 the KNumberOfLinesToKeepVisibleDuringScroll constant.*/
 const TInt KMinProportionOfScreenToScroll = 600;
-/**
-Tests for a high surrogate.
-@param a UTF16 value.
-@return ETrue if argument is a high surrogate.
-@internalComponent
-*/
-inline TBool IsHighSurrogate(TText a) { return 0xD800 == (a & 0xFC00); }
-/**
-Tests for a low surrogate.
-@param a UTF16 value.
-@return ETrue if argument is a high surrogate.
-@internalComponent
-*/
-inline TBool IsLowSurrogate(TText a) { return 0xDC00 == (a & 0xFC00); }
-/**
-Adds a high surrogate to a low surrogate to create a supplementary character.
-@param aHigh UTF16 high surrogate.
-@param aLow UTF16 low surrogate.
-@return Supplementary character represented by the pair <aHigh, aLow>.
-@pre aHigh is a high surrogate and aLow is a low surrogate.
-@internalComponent
-*/
-inline TChar PairSurrogates(TText aHigh, TText aLow)
-	{
-	return ((aHigh - 0xd7f7) << 10) + aLow;
-	}
 /**
 Constructs an iterator over the text referenced by aSource.
 @param aSource The source of the text to be iterated over.
 */
 	valid surrogate pair or an unpaired surrogate, the surrogate is returned.
 */
 TChar CTextLayout::TUtf32SourceCache::GetUtf32(TInt aIndex)
 	{
 	TText code = GetUtf16(aIndex);
-	if (IsHighSurrogate(code) && iSource->DocumentLength() < aIndex + 1)
+	if (TChar::IsHighSurrogate(code) && iSource->DocumentLength() < aIndex + 1)
 		{
 		TText code2 = GetUtf16(aIndex + 1);
-		if (IsLowSurrogate(code2))
+		if (TChar::IsLowSurrogate(code2))
-			return PairSurrogates(code, code2);
+			return TChar::JoinSurrogate(code, code2);
 		}
 	return code;
 	}
 /** Allocates and constructs a CTextLayout object. By default, the formatting
 void CTextLayout::EndRedraw()
 	{
 	if(!iReadyToRedraw)
 		return;
+	if (iBeginRedrawCount <= 0)
+	    {
+	    OstTrace0( TRACE_DUMP, CTEXTLAYOUT_ENDREDRAW, "CTextLayout::EndRedraw" );
+	    }
 	__ASSERT_ALWAYS(iBeginRedrawCount > 0, Panic(EInvalidRedraw));
 	if (0 == --iBeginRedrawCount)
 		{
 		if (NULL != iWnd)
 		}
 	}
 void CTextLayout::SetExternalDraw(const TRect& aRect)
 	{
+	if (0 != iBeginRedrawCount)
+	    {
+	    OstTrace0( TRACE_FATAL, DUP1_CTEXTLAYOUT_SETEXTERNALDRAW, "EInvalidRedraw" );
+	    }
 	__ASSERT_ALWAYS(0 == iBeginRedrawCount, Panic(EInvalidRedraw));
 	iBeginRedrawCount++;
 	iRedrawRect = aRect;
 	}
 void CTextLayout::ResetExternalDraw()
 	{
+	if (1 != iBeginRedrawCount)
+	    {
+	    OstTrace0( TRACE_FATAL, CTEXTLAYOUT_RESETEXTERNALDRAW, "EInvalidRedraw" );
+	    }
 	__ASSERT_ALWAYS(1 == iBeginRedrawCount, Panic(EInvalidRedraw));
 	iBeginRedrawCount--;
 	iRedrawRect = TRect();
 	}
 EXPORT_C void CTextLayout::SetFormatMode(CLayoutData::TFormatMode aFormatMode,TInt aWrapWidth,
 										 MGraphicsDeviceMap* aFormatDevice)
 	{
 	if (aFormatMode == CLayoutData::EFWysiwygMode || aFormatMode == CLayoutData::EFPrintPreviewMode)
 		{
+		if (aFormatDevice == NULL)
+		    {
+		    OstTrace0( TRACE_FATAL, CTEXTLAYOUT_SETFORMATMODE, "EFormatDeviceNotSet" );
+		    }
 		__ASSERT_ALWAYS(aFormatDevice != NULL,Panic(EFormatDeviceNotSet));
 		iSource->iFormatDevice = aFormatDevice;
 		}
 	else
 		iSource->iFormatDevice = iSource->iImageDevice;
 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 );
+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. */
 @param aLineNo Line number in formatted text, counting the first line as line
 one.
 @return The document position of the first character on the line. */
 EXPORT_C TInt CTextLayout::FirstCharOnLine(TInt aLineNo) const
 	{
+	if (aLineNo <= 0)
+	    {
+	    OstTrace0( TRACE_DUMP, CTEXTLAYOUT_FIRSTCHARONLINE, "EInvalidLineNumber" );
+	    }
 	__ASSERT_DEBUG(aLineNo > 0,Panic(EInvalidLineNumber));
 	if (iText->StartChar() == iText->EndChar())
 		return EFNoCurrentFormat;
 	aLineNo--;
 	TTmLineInfo info;
 			iSource->GetText( r - 1, text, format );
 			if ( text.Length() > 1 )
 				{
 				TUint highSurrogate = text[0];
 				TUint lowSurrogate = text[1];
-				if ( IsHighSurrogate( highSurrogate ) &&
+				if ( TChar::IsHighSurrogate( highSurrogate ) &&
-				     IsLowSurrogate( lowSurrogate ) )
+				        TChar::IsLowSurrogate( lowSurrogate ) )
 					--r;
 				}
 			}
 		}
 	TInt xCoords[4];
 	if (iText->LayoutHeight() == 0)
 		return TRect(0,0,0,0);
+	if (!PosIsFormatted(aDocPos1))
+	    {
+	    OstTrace0( TRACE_FATAL, CTEXTLAYOUT_GETLINERECTL, "ECharacterNotFormatted" );
+	    }
 	__ASSERT_ALWAYS(PosIsFormatted(aDocPos1),Panic(ECharacterNotFormatted));
+	if (!PosIsFormatted(aDocPos2))
+	    {
+	    OstTrace0( TRACE_DUMP, DUP1_CTEXTLAYOUT_GETLINERECTL, "ECharacterNotFormatted" );
+	    }
 	__ASSERT_DEBUG(PosIsFormatted(aDocPos2),Panic(ECharacterNotFormatted));
 	TTmDocPosSpec docSpec(aDocPos1, TTmDocPosSpec::ELeading);
 	TTmPosInfo2 pos_info;
 	xCoords[0] = point.iX;
 	// Getthe Line rectangle
 	GetLineRect(point.iY,rect);
+	if (rect.iTl.iY > point.iY || rect.iBr.iY < point.iY)
+	    {
+	    OstTrace0( TRACE_DUMP, DUP2_CTEXTLAYOUT_GETLINERECTL, "EPixelNotInFormattedLine" );
+	    }
 	__ASSERT_DEBUG(rect.iTl.iY <= point.iY && rect.iBr.iY >= point.iY,Panic(EPixelNotInFormattedLine));
 	//	Finding the leading edge of aDocPos2
 	docSpec.iPos = aDocPos2;
 	TBool isformatted = FindDocPos(docSpec, pos_info);
 	iText->SetTextL(*iSource,param);
 	param.iMaxHeight = KMaxTInt;
 	if(IsFormattingBand() && (iText->EndChar() <= aEndDocPos && iText->EndChar() < iSource->DocumentLength()))
 		{
-		param.iEndChar = aEndDocPos;
+		param.iEndChar = Min(aEndDocPos+1,iSource->DocumentLength());
 		iText->ExtendFormattingDownwardsL(param);
 		}
 	else
 		{
 		while (iText->EndChar() <= aEndDocPos && iText->EndChar() < iSource->DocumentLength())
 @pre aDocPos is in the range 0...DocumentLength
 @post aDocPos has been formatted
 */
 EXPORT_C void CTextLayout::ExtendFormattingToCoverPosL(TInt aDocPos)
 	{
+	if (0 > aDocPos || aDocPos > DocumentLength())
+	    {
+	    OstTrace0( TRACE_DUMP, CTEXTLAYOUT_EXTENDFORMATTINGTOCOVERPOSL, "EInvalidDocPos" );
+	    }
 	__ASSERT_DEBUG(0 <= aDocPos && aDocPos <= DocumentLength(),
 			Panic(EInvalidDocPos));
 	TTmFormatParam param;
 	InitFormatParam(param);
 	param.iStartChar = iText->StartChar();
 	param.iEndChar = aDocPos + 1;
 	if(iText->EndChar() < param.iEndChar)
 		{
 		iText->ExtendFormattingDownwardsL(param);
 		}
+	if ((aDocPos < iText->StartChar()) || (aDocPos > iText->EndChar()))
+	    {
+	    OstTrace0( TRACE_DUMP, DUP1_CTEXTLAYOUT_EXTENDFORMATTINGTOCOVERPOSL, "ECharacterNotFormatted" );
+	    }
 	__ASSERT_DEBUG((aDocPos >= iText->StartChar()) && (aDocPos <= iText->EndChar()),
 			Panic(ECharacterNotFormatted));
 	}
 	FormatCharRangeL(aStartDocPos,aEndDocPos,0);
 	}
 void CTextLayout::FormatCharRangeL(TInt aStartDocPos,TInt aEndDocPos,TInt aPixelOffset)
 	{
+	if (aStartDocPos < 0 && aStartDocPos > DocumentLength())
+	    {
+	    OstTrace0( TRACE_DUMP, CTEXTLAYOUT_FORMATCHARRANGEL, "EInvalidDocPos" );
+	    }
 	__ASSERT_DEBUG(aStartDocPos >= 0 && aStartDocPos <= DocumentLength(),Panic(EInvalidDocPos));
+	if (aEndDocPos < 0 || aEndDocPos > DocumentLength())
+	    {
+	    OstTrace0( TRACE_DUMP, DUP1_CTEXTLAYOUT_FORMATCHARRANGEL, "EInvalidDocPos" );
+	    }
 	__ASSERT_DEBUG(aEndDocPos >= 0 && aEndDocPos <= DocumentLength(),Panic(EInvalidDocPos));
+	if (aStartDocPos > aEndDocPos)
+	    {
+	    OstTrace0( TRACE_DUMP, DUP2_CTEXTLAYOUT_FORMATCHARRANGEL, "ENoCharRangeToFormat" );
+	    }
 	__ASSERT_DEBUG(aStartDocPos <= aEndDocPos,Panic(ENoCharRangeToFormat));
 	TTmFormatParam param;
 	InitFormatParam(param);
 	param.iStartChar = iSource->ParagraphStart(aStartDocPos);
 		if (result.iUnformattedStart == KMaxTInt)
 			{
 			TTmLineInfo info;
 			TTmDocPos pos(iUnformattedStart, ETrue);
 			TBool isFormatted = iText->DocPosToLine(pos,info);
+			if (!isFormatted)
+			    {
+			    OstTrace0( TRACE_DUMP, CTEXTLAYOUT_FORMATNEXTLINEL, "EPosNotFormatted" );
+			    }
 			__ASSERT_DEBUG(isFormatted, Panic(EPosNotFormatted));
 			isFormatted = iText->ParNumberToLine(info.iParNumber,KMaxTInt,info);
+			if (!isFormatted)
+			    {
+			    OstTrace0( TRACE_DUMP, DUP1_CTEXTLAYOUT_FORMATNEXTLINEL, "EPosNotFormatted" );
+			    }
 			__ASSERT_DEBUG(isFormatted, Panic(EPosNotFormatted));
 			aBottomPixel = info.iOuterRect.iBr.iY - iBandTop;
 			}
 		// Indicate that formatting is complete up to the lower edge of the current line.
 			else
 				{
 				if (iText->YPosToLine(iBandTop,info))
 					top_line_number = info.iLineNumber;
 				else
+				    {
+					OstTrace0( TRACE_DUMP, DUP1_CTEXTLAYOUT_SCROLLLINESL, "EPosNotFormatted" );
 					User::Leave(EPosNotFormatted);
+					}
 				partial_line = iBandTop > info.iOuterRect.iTl.iY;
 				}
 			// Find the line number of the desired first visible line.
 			// Defect fix for INC015850. Changed IF so that if the currently
 			}
 		aLines -= lines_scrolled;
 		if (lines_scrolled)
 			{
 			if (!iText->LineNumberToLine(desired_top_line_number,info))
-				User::Leave(EPosNotFormatted);
+			    {
+			    OstTrace0( TRACE_DUMP, CTEXTLAYOUT_SCROLLLINESL, "EPosNotFormatted" );
+			    User::Leave(EPosNotFormatted);
+			    }
 			// if the line to be scrolled to is taller than the screen, we want
 			// to make sure that the baseline is not scrolled off the screen.
 			if (visible_height < info.iBaseline - info.iOuterRect.iTl.iY)
 				return ScrollL(iBandTop + visible_height - info.iBaseline, aScrollBlankSpace);
 			return ScrollL(iBandTop - info.iOuterRect.iTl.iY,aScrollBlankSpace);
 		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);
+			    {
+			    OstTrace0( TRACE_DUMP, DUP2_CTEXTLAYOUT_SCROLLLINESL, "EPosNotFormatted" );
+			    User::Leave(EPosNotFormatted);
+			    }
 			return ScrollL(-info.iOuterRect.Height(), aScrollBlankSpace);
 			}
 		int desired_bottom_line_number = 0;
 		int band_bottom = iBandTop + visible_height;
 			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);
+			    {
+			    OstTrace0( TRACE_DUMP, DUP3_CTEXTLAYOUT_SCROLLLINESL, "EPosNotFormatted" );
+			    User::Leave(EPosNotFormatted);
+			    }
 			partial_line = band_bottom < info.iOuterRect.iBr.iY;
 			// Find the line number of the desired last visible line.
 			desired_bottom_line_number = bottom_line_number - aLines;
 			if (partial_line)
 			}
 		aLines -= lines_scrolled;
 		if (lines_scrolled)
 			{
 			if (!iText->LineNumberToLine(desired_bottom_line_number,info))
-				User::Leave(EPosNotFormatted);
+			    {
+			    OstTrace0( TRACE_DUMP, DUP4_CTEXTLAYOUT_SCROLLLINESL, "EPosNotFormattedL" );
+			    User::Leave(EPosNotFormatted);
+			    }
 			return ScrollL(band_bottom - info.iOuterRect.iBr.iY,aScrollBlankSpace);
 			}
 		else
 			return 0;
 		}
 		EFDisallowScrollingBlankSpace);
 	aYCursorPos = aPixelsScrolled == 0?
 		visible_height - 1
 		: SuggestCursorPos(aYCursorPos);
+	if (-visible_height > aPixelsScrolled)
+	    {
+	    OstTrace0( TRACE_DUMP, CTEXTLAYOUT_PAGEDOWNL, "EPageScrollError" );
+	    }
 	__ASSERT_DEBUG(-visible_height <= aPixelsScrolled,
 		Panic(EPageScrollError));
+	if (0 > aYCursorPos || aYCursorPos > visible_height)
+	    {
+	    OstTrace0( TRACE_DUMP, DUP1_CTEXTLAYOUT_PAGEDOWNL, "EPageScrollError" );
+	    }
 	__ASSERT_DEBUG(0 <= aYCursorPos && aYCursorPos <= visible_height,
 		Panic(EPageScrollError));
 	}
 /** Reformats to reflect a single character edit.
 @return EFalse if no more lines need to be reformatted. ETrue if some more lines
 need to be reformatted. */
 EXPORT_C TBool CTextLayout::HandleCharEditL(TUint aType,TInt& aCursorPos,TInt& aGood,TInt& aFormatBottom,
 											TInt& aFormatTop,TInt& aScroll,TBool aFormatFromStartOfPar)
 	{
+	if (iSource->iFormatMode == CLayoutData::EFPrintPreviewMode)
+	    {
+	    OstTrace0( TRACE_FATAL, DUP2_CTEXTLAYOUT_HANDLECHAREDITL, "EPrintPreviewModeError" );
+	    }
 	__ASSERT_ALWAYS(iSource->iFormatMode != CLayoutData::EFPrintPreviewMode,Panic(EPrintPreviewModeError));
+	if (aType > EFRightDelete)
+	    {
+	    OstTrace0( TRACE_FATAL, CTEXTLAYOUT_HANDLECHAREDITL, "EBadCharacterEditType" );
+	    }
 	__ASSERT_ALWAYS(aType <= EFRightDelete,Panic(EBadCharacterEditType));
+	if (!(!aFormatFromStartOfPar || aType == EFRightDelete || aType == EFLeftDelete))
+	    {
+	    OstTrace0( TRACE_FATAL, DUP1_CTEXTLAYOUT_HANDLECHAREDITL, "EBadCharacterEditType" );
+	    }
 	__ASSERT_ALWAYS(!aFormatFromStartOfPar || aType == EFRightDelete || aType == EFLeftDelete,Panic(EBadCharacterEditType));
+	if (aCursorPos < iText->StartChar() || aCursorPos >= iText->EndChar())
+	    {
+	    OstTrace0( TRACE_FATAL, DUP3_CTEXTLAYOUT_HANDLECHAREDITL, "ECharacterNotFormatted" );
+	    }
 	__ASSERT_ALWAYS(aCursorPos >= iText->StartChar() && aCursorPos < iText->EndChar(),Panic(ECharacterNotFormatted));
 	// Mark the entire paragraph invalid if background formatting is taking place.
 	iParInvalid = iUnformattedStart != KMaxTInt;
 	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;
 must extend out to paragraph boundaries and cannot be restricted to only some
 lines. */
 EXPORT_C void CTextLayout::HandleBlockChangeL(TCursorSelection aSelection,TInt aOldLength,
 											  TViewRectChanges& aChanges,TBool aFormatFromStartOfPar)
 	{
+	if (iSource->iFormatMode == CLayoutData::EFPrintPreviewMode)
+	    {
+	    OstTrace0( TRACE_FATAL, CTEXTLAYOUT_HANDLEBLOCKCHANGEL, "EPrintPreviewModeError" );
+	    }
 	__ASSERT_ALWAYS(iSource->iFormatMode != CLayoutData::EFPrintPreviewMode,Panic(EPrintPreviewModeError));
 	// Do nothing if the selection is outside the formatted range.
 	if (aSelection.LowerPos() > iText->EndChar() || aSelection.HigherPos() < iText->StartChar())
 		{
 application's year view). */
 EXPORT_C void CTextLayout::AdjustVerticalAlignment(CParaFormat::TAlignment aVerticalAlignment)
 	{
 	int excess = BandHeight() - FormattedHeightInPixels();
 	int space_before = 0;
+	if (IsFormattingBand())
+	    {
+	    OstTrace0( TRACE_FATAL, CTEXTLAYOUT_ADJUSTVERTICALALIGNMENT, "EMustFormatAllText" );
+	    }
 	__ASSERT_ALWAYS(!IsFormattingBand(),Panic(EMustFormatAllText));
 	TTmLineInfo info;
 	switch (aVerticalAlignment)
 		{
 			};
 // Repeat draw, for double border.
 		if (aBorder.iBorder[border].iLineStyle==TParaBorder::EDouble)	 // Now have only got solid border, drawn as rect.
 			{
+			if (drawAsLine)
+			    {
+			    OstTrace0( TRACE_DUMP, CTEXTLAYOUT_DRAWBORDERS, "EDrawingBorderError" );
+			    }
 			__ASSERT_DEBUG(!drawAsLine,Panic(EDrawingBorderError));
 			(*ptrStartWidth)-=directionOut*widthInPixels[border];
 			(*ptrEndWidth)-=directionOut*widthInPixels[border];
 			(*ptrStartLength)+=widthInPixels[indexJoint1];
 			(*ptrEndLength)-=widthInPixels[indexJoint2];
 	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)
 		while (iText->LayoutHeight() - iBandTop < visible_height)
 			{
 			if (!AddFormattingAtEndL(param, height_increase,paragraphs_increase))
 				break;
 			}
-		// Shift the whole band upwards if we're at the very end of the text
-		// and there's no more text to format. This prevents a situation were
-		// iText->LayoutHeight() < BandHeightInPixels.
-		if ( aBottomNoLimitBorder && iText->LayoutHeight() - iBandTop < visible_height )
-		    {
-		    if ( iText->EndChar() > iText->Source()->DocumentLength() )
-		        {
-		        iBandTop = desired_bandtop;
-		        return pixels_scrolled;
-		        }
-		    }
 		}
 	// Scroll blank space off the display if desired.
 	if (aScrollBlankSpace == EFDisallowScrollingBlankSpace && iText->LayoutHeight() - iBandTop < visible_height)
 		{
 	return pixels_scrolled + SetBandTop();
 	}
 TInt CTextLayout::ScrollDocPosIntoViewL(const TTmDocPos& aDocPos)
 	{
+	if (aDocPos.iPos > iText->Source()->DocumentLength())
+	    {
+	    OstTrace0( TRACE_DUMP, CTEXTLAYOUT_SCROLLDOCPOSINTOVIEWL, "EInvalidDocPos" );
+	    }
 	__ASSERT_DEBUG(aDocPos.iPos <= iText->Source()->DocumentLength(),
 		Panic(EInvalidDocPos));
 	TTmLineInfo info;
 	ExtendFormattingToCoverPosL(aDocPos.iPos);
 	if (!iText->DocPosToLine(aDocPos,info))
 		{
+		if (iText->Source()->DocumentLength() != 0)
+		    {
+		    OstTrace0( TRACE_DUMP, DUP1_CTEXTLAYOUT_SCROLLDOCPOSINTOVIEWL, "ECharacterNotFormatted" );
+		    }
 		__ASSERT_DEBUG(iText->Source()->DocumentLength() == 0,
 			Panic(ECharacterNotFormatted));
 		return ScrollL(iBandTop, EFDisallowScrollingBlankSpace);
 		}
 	TRect line_rect = info.iOuterRect;

branch	RCL_3
changeset 54	748ec5531811
parent 13	7ff7c6e94fea
child 55	336bee5c2d35