1 /*

     2 * Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

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

    16 *

    17 */

    18 

    19 

    20 #include "TmLayoutImp.h"

    21 #include "TmHighlightSource.h"

    22 #include "TMINTERP.H"

    23 #include "TmChunkInterp.h"

    24 #include <txtfrmat.h>

    25 #include "TmTextDrawExt.h"

    26 #include <frmtlay.h>

    27 #include "tmreformat.h"

    28 #include "frmUtils.h"

    29 

    30 #define UNUSED_VAR(a) a = a

    31 

    32 /**

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

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

    35 */

    36 EXPORT_C TTmFormatParamBase::TTmFormatParamBase():

    37 	iWrapWidth(KMaxTInt),

    38 	iMaxHeight(KMaxTInt),

    39 	iMaxLines(KMaxTInt),

    40 	iFlags(0),

    41 	iEllipsis(0x2026)

    42 	{

    43 	}

    44 

    45 /**

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

    47 */

    48 EXPORT_C TTmFormatParam::TTmFormatParam():

    49 	iStartChar(0),

    50 	iEndChar(KMaxTInt),

    51 	iLineInPar(0)

    52 	{

    53 	}

    54 

    55 /**

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

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

    58 */

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

    60 	TTmFormatParamBase(aBase),

    61 	iStartChar(0),

    62 	iEndChar(KMaxTInt),

    63 	iLineInPar(0)

    64 	{

    65 	}

    66 

    67 /**

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

    69 set to 'infinity' (KMaxTInt).

    70 */

    71 EXPORT_C TTmReformatParam::TTmReformatParam():

    72 	iStartChar(0), 

    73 	iOldLength(0),

    74 	iNewLength(0),

    75 	iMaxExtraLines(KMaxTInt),

    76 	iParFormatChanged(FALSE),

    77 	iParInvalid(FALSE)

    78 	{

    79 	}

    80 

    81 /**

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

    83 'infinity' (KMaxTInt).

    84 */

    85 EXPORT_C TTmReformatResult::TTmReformatResult():

    86 	iHeightChange(0),

    87 	iUnchangedTop(KMaxTInt),

    88 	iUnformattedStart(KMaxTInt)

    89 	{

    90 	}

    91 

    92 /**

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

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

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

    96 */

    97 EXPORT_C CTmTextLayout::CTmTextLayout() :

    98 	iCurrentContextChar(NULL)

    99 	{

   100 	// do nothing

   101 	}

   102 

   103 /**

   104 The destructor.

   105 */

   106 EXPORT_C CTmTextLayout::~CTmTextLayout()

   107 	{

   108 	delete iBdStateAtEnd;

   109 	}

   110 

   111 /**

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

   113 extracted from aSource and formatted.

   114 */

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

   116 	{

   117 	if (aParam.iMaxHeight <= 0 ||

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

   119 		aParam.iLineInPar < 0)

   120 		TmPanic(EBadArg);

   121 		

   122 	if (iBdStateAtEnd)

   123 		{

   124 		iBdStateAtEnd->Reset();

   125 		}

   126 	else

   127 		{

   128 		iBdStateAtEnd = new(ELeave) TBidirectionalContext;

   129 		}

   130 

   131 		

   132 	iSource = &aSource;

   133 	iCode.Reset();

   134 	iStartChar = aParam.iStartChar;

   135 	CTmFormatContext::TInfo info;

   136 	if (aParam.iFlags & TTmFormatParamBase::EWrap

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

   138 		{

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

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

   141 		iHeight = 0;

   142 		iEndChar = iStartChar;

   143 		iWidth = 0;

   144 		}

   145 	else

   146 		{

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

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

   149 		TTmInterpreter interpreter(TTmInterpreterParam(*this));

   150 		TBool lineFound = interpreter.DocPosToLine(startDocPos);

   151 		if (lineFound)

   152 			info.iContextCharPerLine = interpreter.LineContextCharChar();

   153 		else

   154 			info.iContextCharPerLine = NULL;

   155 		

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

   157 		iHeight = info.iHeight;

   158 		iEndChar = info.iEndChar;

   159 		iWidth = 0;

   160 		AdjustWidth(aParam,info.iWidth);

   161 		}

   162 	}

   163 

   164 /**

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

   166 

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

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

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

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

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

   172 */

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

   174 									 TTmReformatResult& aResult)

   175 	{

   176 	if (!iSource)

   177 		TmPanic(ENoSource);

   178 

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

   180 	reformat->ReformatL();

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

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

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

   184 	TBool bd_changed = reformat->BidirectionalStateChanged();

   185 	/*

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

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

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

   189 

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

   191 	*/

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

   193 		{

   194 		aResult.iRedrawRect = oldCodeInfo.iBounds;

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

   196 		}

   197 	else

   198 		{

   199 		TTmInterpreterParam p(*this);

   200 		p.iCodeStart = oldCodeInfo.iStartCodePos;

   201 		p.iCodeEnd = oldCodeInfo.iEndCodePos;

   202 		p.iTextStart = oldCodeInfo.iStartInfo.iStart;

   203 		TTmInterpreter old_code_interpreter(p);

   204 		p.iByteCode = new_code;

   205 		p.iCodeStart = 0;

   206 		p.iCodeEnd = new_code->Size();

   207 		TTmInterpreter new_code_interpreter(p);

   208 		old_code_interpreter.CalculateRedrawRect(new_code_interpreter,aReformatParam.iStartChar,

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

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

   211 		}

   212 

   213 	// Delete the old bytecode and insert the new.

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

   215 

   216 	// Adjust the band's bounds.

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

   218 	

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

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

   221 	if(oldCodeInfo.iEndInfo.iEnd == iEndChar)

   222 		{

   223 		*iBdStateAtEnd = reformat->BidirectionalStateAtEnd();

   224 		}

   225 	// Adjust the band's width if necessary.

   226 	AdjustWidth(aParam,newCodeInfo.iWidth);

   227 

   228 	// Adjust the band's length.

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

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

   231 	iEndChar += lengthOfNewRange - lengthOfOldRange;

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

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

   234 

   235 	/*

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

   237 	remove the first unformatted line from the redraw rect.

   238 	*/

   239 	if (aResult.iUnformattedStart < KMaxTInt)

   240 		{

   241 		TTmLineInfo info;

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

   243 		DocPosToLine(pos,info);

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

   245 		ParNumberToLine(info.iParNumber,KMaxTInt,info);

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

   247 		}

   248 	else

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

   250 

   251 	CleanupStack::PopAndDestroy(reformat);

   252 	

   253 	Invariant();

   254 	}

   255 

   256 /**

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

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

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

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

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

   262 

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

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

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

   266 

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

   268 */

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

   270 									  TInt& aParagraphsIncrease)

   271 	{	

   272 	if (!iSource)

   273 		TmPanic(ENoSource);

   274 

   275 	aHeightIncrease = 0;

   276 	aParagraphsIncrease = 0;

   277 	int start_char = 0;

   278 	int end_char = 0;

   279 	int deleted_height = 0;

   280 	TTmFormatParam format_param(aParam);

   281 

   282 	TBidirectionalContext* pStartBd = NULL;

   283 	TBidirectionalContext* pEndBd = NULL;

   284 	TBidirectionalEndOfLineContext* pEOLContext = NULL;		

   285 	

   286 	if (aAtStart)

   287 		{

   288 		if (iStartChar == 0)

   289 			return FALSE;

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

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

   292 		if (end_char > iStartChar)

   293 			{

   294 			if (end_char > iEndChar)

   295 				end_char = iEndChar;

   296 			DeletePar(aParam,TRUE,KMaxTInt,deleted_height);

   297 			}

   298 		else

   299 			aParagraphsIncrease = 1;

   300 		}

   301 	else

   302 		{

   303 		if (iEndChar > iSource->DocumentLength())

   304 			return FALSE;

   305 		start_char = iEndChar;

   306 		end_char = iSource->ParagraphEnd(iEndChar);

   307 		

   308 		pStartBd = iBdStateAtEnd;

   309 		pEndBd = iBdStateAtEnd;

   310 			

   311 		TInt lastLineNumber = Lines()-1;

   312 		if(lastLineNumber >= 0)

   313 			{

   314 			TTmLineInfo lastLine;

   315 			TBool found = LineNumberToLine(lastLineNumber, lastLine);

   316 			ASSERT(found);

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

   318 				{

   319 				format_param.iLineInPar = lastLine.iLineInPar+1;

   320 				}

   321 			}				

   322 						

   323 		aParagraphsIncrease = 1; 

   324 		}

   325 

   326 	CTmCode* new_code = new(ELeave) CTmCode;

   327 	CleanupStack::PushL(new_code);

   328 	format_param.iStartChar = start_char;

   329 	format_param.iEndChar = end_char;

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

   331 	CTmFormatContext::TInfo info;

   332 	

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

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

   335 	TTmInterpreter interpreter(TTmInterpreterParam(*this));

   336 	TBool lineFound = interpreter.DocPosToLine(startDocPos);

   337 	if (lineFound)

   338 		info.iContextCharPerLine = interpreter.LineContextCharChar();

   339 	else

   340 		info.iContextCharPerLine = NULL;

   341 	

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

   343 		pStartBd, pEndBd, pEOLContext);

   344 

   345 	// Insert the new code if any.

   346 	aHeightIncrease = info.iHeight;

   347 	if (aHeightIncrease > 0)

   348 		{

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

   350 

   351 		iHeight += aHeightIncrease;

   352 		if (aAtStart)

   353 			iStartChar = start_char;

   354 		else

   355 			iEndChar = info.iEndChar;

   356 

   357 		// Adjust the band's width if necessary.

   358 		AdjustWidth(aParam,info.iWidth);

   359 		}

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

   361 	if(!aAtStart)

   362 		{

   363 		if(iEndChar == format_param.iEndChar)

   364 			{

   365 			iBdStateAtEnd->Reset();

   366 			}

   367 		}

   368 	CleanupStack::PopAndDestroy();	// new code

   369 	aHeightIncrease -= deleted_height;

   370 	

   371 	Invariant();

   372 	

   373 	return aHeightIncrease > 0;

   374 	}

   375 	

   376 TBool CTmTextLayout::LastLine(TTmLineInfo& aLine)

   377 	{

   378 	TInt lastLineNumber = Lines()-1;

   379 	if(lastLineNumber >= 0)

   380 		{

   381 		TTmLineInfo lastLine;

   382 		TBool found = LineNumberToLine(lastLineNumber, aLine);

   383 		ASSERT(found);

   384 		return ETrue;

   385 		}

   386 	return EFalse;	

   387 	}

   388 

   389 void CTmTextLayout::SetCurrentContextChar(TUint aContextChar)

   390 	{

   391 	iCurrentContextChar = aContextChar;

   392 	}

   393 	

   394 TUint CTmTextLayout::GetCurrentContextChar() const

   395 	{

   396 	return iCurrentContextChar;

   397 	}

   398 /**

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

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

   401 @param aParam 

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

   403 - the character position specified in TTmFormatParam::iEndChar

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

   405 - the number of lines specified in TTmFormatParamBase::iMaxLines

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

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

   408 */

   409 EXPORT_C void CTmTextLayout::ExtendFormattingDownwardsL(TTmFormatParam& aParam)

   410 	{

   411 	if (!iSource)

   412 		TmPanic(ENoSource);

   413 

   414 	aParam.iStartChar = iEndChar;

   415 

   416 	if (iEndChar > iSource->DocumentLength())

   417 		return;

   418 	if (aParam.iStartChar > aParam.iEndChar)

   419 		return;

   420 		

   421 	TBidirectionalContext* pStartBd = iBdStateAtEnd;

   422 	TBidirectionalContext* pEndBd = iBdStateAtEnd;

   423 	TBidirectionalEndOfLineContext* pEOLContext = NULL;		

   424 

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

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

   427 	//then initialise the line number				

   428 	TTmLineInfo lastLine;

   429 	TBool found = LastLine(lastLine);

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

   431 		{

   432 		aParam.iLineInPar = lastLine.iLineInPar+1;

   433 		}				

   434 	

   435 	//Generate the additional formatting

   436 	CTmCode* newCode = new(ELeave) CTmCode;

   437 	CleanupStack::PushL(newCode);

   438 

   439 	TInt newCodePos = iCode.Size();

   440 	CTmFormatContext::TInfo info;

   441 	

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

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

   444 	TTmInterpreter interpreter(TTmInterpreterParam(*this));

   445 	TBool lineFound = interpreter.DocPosToLine(startDocPos);

   446 	if (lineFound)

   447 		info.iContextCharPerLine = interpreter.LineContextCharChar();

   448 	else

   449 		info.iContextCharPerLine = NULL;

   450 	

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

   452 

   453 	// Insert the new code if any.

   454 	if (info.iHeight > 0)

   455 		{

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

   457 		iHeight += info.iHeight;

   458 		iEndChar = info.iEndChar;

   459 		AdjustWidth(aParam,info.iWidth);

   460 		}

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

   462 	found = LastLine(lastLine);

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

   464 		{

   465 		iBdStateAtEnd->Reset();

   466 		}

   467 

   468 	CleanupStack::PopAndDestroy();	// new code

   469 	Invariant();	

   470 	}

   471 

   472 /**

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

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

   475 */

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

   477 										TInt& aHeightDecrease)

   478 	{

   479 	aHeightDecrease = 0;

   480 	if (!iSource || iStartChar >= iEndChar)

   481 		return FALSE;

   482 

   483 	int pos = aAtStart ? iStartChar : iEndChar - 1;

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

   485 	TTmByteCodeFinder::TInfo info;

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

   487 		TmPanic(EFormatNotFound);

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

   489 		return FALSE;

   490 

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

   492 	if (aAtStart)

   493 		iStartChar = info.iEndInfo.iEnd;

   494 	else

   495 		iEndChar = info.iStartInfo.iStart;

   496 	aHeightDecrease = info.iBounds.Height();

   497 	iHeight -= aHeightDecrease;

   498 

   499 	// Adjust the band's width if necessary.

   500 	AdjustWidth(aParam,0);

   501 	

   502 	Invariant();

   503 	

   504 	return TRUE;

   505 	}

   506 	

   507 /** 

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

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

   510 */

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

   512 	{

   513 	aHeightDecrease = 0;

   514 	if (!iSource || iStartChar >= iEndChar)

   515 		return;

   516 	TBidirectionalContext* bdStart = new(ELeave) TBidirectionalContext;

   517 	CleanupStack::PushL(bdStart);

   518 	TBidirectionalContext* bdEnd = new(ELeave) TBidirectionalContext;

   519 	CleanupStack::PushL(bdEnd);

   520 	TTmByteCodeFinder::TInfo info;

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

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

   523 	if (!found)

   524 		{

   525 		CleanupStack::PopAndDestroy(2);

   526 		}

   527 	else

   528 		{

   529 		//should use an assignment operator here instead

   530 		delete iBdStateAtEnd;

   531 		iBdStateAtEnd = bdStart;

   532 		CleanupStack::PopAndDestroy(bdEnd);

   533 		CleanupStack::Pop(bdStart);

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

   535 		iEndChar = info.iStartInfo.iStart;

   536 		aHeightDecrease = info.iBounds.Height();

   537 		iHeight -= aHeightDecrease;

   538 		// Adjust the band's width if necessary.

   539 		AdjustWidth(aParam,0);

   540 		Invariant();

   541 		}	

   542 	}

   543 

   544 /**

   545 Reset the object to its empty state; no source or formatting, height and width of 0, start and end char both 0.

   546 */

   547 EXPORT_C void CTmTextLayout::Clear()

   548 	{

   549 	if(iBdStateAtEnd)

   550 		iBdStateAtEnd->Reset();

   551 	iSource = NULL;

   552 	iCode.Reset();

   553 	iWidth = 0;

   554 	iHeight = 0;

   555 	iStartChar = 0;

   556 	iEndChar = 0;

   557 

   558 	Invariant();

   559 	}

   560 

   561 /**

   562 Draw the text.

   563 

   564 @param aGc

   565 	Graphics context to draw to.

   566 @param aTopLeft

   567 	The origin of the formatted text in the coordinates of aGc.

   568 @param aClipRect

   569 	The clipping rectangle in the coordinates of aGc. Nowhere outside this

   570 	rectangle will be drawn.

   571 @param aDocBackground

   572 	The default document background colour, which is used for regions not drawn

   573 	by any custom background drawing routine and not covered by any text. If

   574 	null, no background is drawn in these places.

   575 @param aDrawParBackground

   576 	If false no default background is drawn on those areas covered by text.

   577 	Custom background drawers are invoked regardless of this argument.

   578 */

   579 

   580 EXPORT_C void CTmTextLayout::DrawLayout(CGraphicsContext& aGc,

   581 	const TPoint& aTopLeft,const TRect& aClipRect,

   582 	const TLogicalRgb* aDocBackground,TBool aDrawParBackground) const

   583 	{

   584 	DrawLayout(aGc, aTopLeft, aClipRect, aDocBackground, aDrawParBackground, NULL, NULL);

   585 	}

   586 

   587 /**

   588 Draw the text.

   589 

   590 @param aGc

   591 	Graphics context to draw to.

   592 @param aTopLeft

   593 	The origin of the formatted text in the coordinates of aGc.

   594 @param aClipRect

   595 	The clipping rectangle in the coordinates of aGc. Nowhere outside this

   596 	rectangle will be drawn.

   597 @param aDocBackground

   598 	The default document background colour, which is used for regions not drawn

   599 	by any custom background drawing routine and not covered by any text. If

   600 	null, no background is drawn in these places.

   601 @param aDrawParBackground

   602 	If false no default background is drawn on those areas covered by text.

   603 	Custom background drawers are invoked regardless of this argument.

   604 @param aHighlight

   605 	The current selection. If null, no selection is drawn.

   606 @param aHighlightExtensions

   607 	If not null, the selection highlight has its edges moved by the specified

   608 	number of pixels

   609 */

   610 

   611 EXPORT_C void CTmTextLayout::DrawLayout(CGraphicsContext& aGc,

   612 	const TPoint& aTopLeft,const TRect& aClipRect,

   613 	const TLogicalRgb* aDocBackground,TBool aDrawParBackground,

   614 	const TCursorSelection* aHighlight,

   615 	const TTmHighlightExtensions* aHighlightExtensions) const

   616 	{

   617 	if (iSource)

   618 		{

   619 		RTmDrawingInterpreter interpreter(*iSource, aGc,

   620 			TTmInterpreterParam(*this), aTopLeft, aClipRect, aDocBackground,

   621 			aDrawParBackground ? RTmDrawingInterpreter::EDrawParBackground : 0,

   622 			aHighlight, aHighlightExtensions);

   623 		interpreter.Draw();

   624 		interpreter.Close();

   625 		}

   626 	}

   627 

   628 /**

   629 Draw the background, using the custom background graphics implemented by overriding MTmSource::DrawBackground if any:

   630 aTopLeft is the top-left corner of the text, aRect is the portion of the background to be drawn, and aBackground is

   631 the default background colour. This function is used by higher-level classes for drawing backgrounds outside the ordinary

   632 text area consistently with the ordinary background.

   633 */

   634 EXPORT_C void CTmTextLayout::DrawBackground(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aClipRect,

   635 											const TLogicalRgb& aBackground) const

   636 	{

   637 	if (iSource)

   638 		{

   639 		RTmDrawingInterpreter interpreter(*iSource, aGc, TTmInterpreterParam(*this),

   640 			aTopLeft, aClipRect, &aBackground, 0, NULL, NULL);

   641 		interpreter.DrawBackground(aClipRect, aBackground);

   642 		interpreter.Close();

   643 		}

   644 	}

   645 

   646 EXPORT_C void CTmTextLayout::InvertLayout(CGraphicsContext& aGc,

   647 	const TPoint& aTopLeft, TInt aStartDocPos,TInt aEndDocPos) const

   648 	{

   649 	TTmHighlightExtensions highlightProperties;

   650 	highlightProperties.SetAll(0);

   651 	InvertLayout(aGc,aTopLeft,aStartDocPos,aEndDocPos,highlightProperties,0,0);

   652 	}

   653 

   654 /**

   655 Analogous to InvertLayout(CGraphicsContext, const TPoint&, TInt, TInt) but with

   656 highlight extensions applied.

   657 @see InvertLayout(CGraphicsContext, const TPoint&, TInt, TInt)

   658 @publishedPartner

   659 @released

   660 */

   661 EXPORT_C void CTmTextLayout::InvertLayout(CGraphicsContext& aGc,

   662 	const TPoint& aTopLeft, TInt aStartDocPos, TInt aEndDocPos,

   663 	const TTmHighlightExtensions& aHighlightExtensions,

   664 	TInt aHighlightStartDocPos, TInt aHighlightEndDocPos) const

   665 	{

   666 	// note: Assumes that RWindow::BeginRedraw() has been called by the caller.

   667 

   668 	if (NULL == iSource)

   669 		{

   670 		return;

   671 		}

   672 

   673 	TRect clipRect;

   674 	GetUpdateBoundingRect(aStartDocPos, aEndDocPos, aTopLeft, clipRect);

   675 

   676 	if (aStartDocPos < aHighlightStartDocPos)

   677 		{

   678 		aHighlightStartDocPos = aStartDocPos;

   679 		}

   680 	

   681 	if (aEndDocPos > aHighlightEndDocPos)

   682 		{

   683 		aHighlightEndDocPos = aEndDocPos;

   684 		}

   685 

   686 	TCursorSelection selection;

   687 	selection.SetSelection(aHighlightStartDocPos, aHighlightEndDocPos);

   688 

   689 	TRect boundingRect;

   690 	GetUpdateBoundingRect(aStartDocPos, aEndDocPos, aTopLeft, boundingRect);

   691 	aHighlightExtensions.AbsExtendRect(boundingRect);

   692 	boundingRect.Intersection(clipRect);

   693 	if (! boundingRect.IsEmpty())

   694 		{

   695 		RTmDrawingInterpreter interpreter(*iSource, aGc, TTmInterpreterParam(*this),

   696 			aTopLeft, boundingRect, NULL, ETrue, &selection, &aHighlightExtensions, ETrue);

   697 		interpreter.Draw();

   698 		interpreter.Close();

   699 		}

   700 	}

   701 

   702 /**

   703 Calculate the bounding rectangle of the region that must be redrawn to redraw the given document section.

   704 @param aStartDocPos

   705 	The section starting position

   706 @param aEndDocPos

   707 	The section ending position

   708 @param aTopLeft

   709 	Textview position in graphics context coordinates. The resulting region can be used

   710 	to clip the drawing in that graphics context.

   711 @param aBoundingRect

   712 	The resulting bounding rectangle, that is the smallest rectangle that should be redrawn

   713 	to redraw the specified document section.

   714 */

   715 EXPORT_C void CTmTextLayout::GetUpdateBoundingRect(TInt aStartDocPos, TInt aEndDocPos,

   716 		const TPoint& aTopLeft, TRect& aBoundingRect) const

   717 	{

   718 	aBoundingRect = TRect(TRect::EUninitialized);

   719 

   720 	if (! iSource || aEndDocPos <= aStartDocPos)

   721 		{

   722 		return;

   723 		}

   724 

   725 	RTmBoundingRectInterpreter interpreter(*iSource, *this);

   726 	TRect rect(TRect::EUninitialized); // set by call to RTmBoundingRectInterpreter::FirstRect

   727 	TTmDocPos start(aStartDocPos, TRUE);

   728 	TTmDocPos end(aEndDocPos,FALSE);

   729 	TBool found = interpreter.FirstRect(start.iPos, end.iPos, rect);

   730 	while (found)

   731 		{

   732 		if (! rect.IsEmpty())

   733 			{

   734 			rect.Move(aTopLeft);

   735 			if(aBoundingRect.IsEmpty())

   736 				{

   737 				aBoundingRect = rect;

   738 				}

   739 			else

   740 				{

   741 				aBoundingRect.BoundingRect(rect);

   742 				}

   743 			}

   744 

   745 		found = interpreter.NextRect(rect);

   746 		}

   747 	interpreter.Close();

   748 	}

   749 

   750 EXPORT_C void CTmTextLayout::HighlightSection(CGraphicsContext& aGc,

   751 	const TPoint& aTopLeft, TInt aStartDocPos, TInt aEndDocPos, const TRect& aClipRect) const

   752 	{

   753 	TTmHighlightExtensions highlightProperties;

   754 	highlightProperties.SetAll(0);

   755 	HighlightSection(aGc,aTopLeft,aStartDocPos,aEndDocPos,aClipRect,highlightProperties,0,0);

   756 	}

   757 

   758 /**

   759 Analogous to HighlightSection(CGraphicsContext&, const TPoint&, TInt, TInt,

   760 const TRect&) but with highlight extensions applied.

   761 @see HighlightSecion(CGraphicsContext&, const TPoint&, TInt, TInt, const

   762 TRect&)

   763 @publishedPartner

   764 @released

   765 */

   766 EXPORT_C void CTmTextLayout::HighlightSection(CGraphicsContext& aGc,

   767 	const TPoint& aTopLeft, TInt aStartDocPos, TInt aEndDocPos,

   768 	const TRect& aClipRect, const TTmHighlightExtensions& aHighlightExtensions,

   769 	TInt aHighlightStartDocPos, TInt aHighlightEndDocPos) const

   770 	{

   771 	if (0 == aHighlightStartDocPos && 0 == aHighlightEndDocPos)

   772 		{

   773 		aHighlightStartDocPos = aStartDocPos;

   774 		aHighlightEndDocPos = aEndDocPos;

   775 		}

   776 	else

   777 		{

   778 		if (aStartDocPos < aHighlightStartDocPos)

   779 			{

   780 			aHighlightStartDocPos = aStartDocPos;

   781 			}

   782 		

   783 		if (aEndDocPos > aHighlightEndDocPos)

   784 			{

   785 			aHighlightEndDocPos = aEndDocPos;

   786 			}

   787 		}

   788 

   789 	DrawSection(aGc, aTopLeft, aStartDocPos, aEndDocPos, aClipRect, aHighlightExtensions,

   790 		aHighlightStartDocPos, aHighlightEndDocPos);

   791 	}

   792 

   793 

   794 EXPORT_C void CTmTextLayout::DrawSection(CGraphicsContext& aGc,

   795 	const TPoint& aTopLeft, TInt aStartDocPos, TInt aEndDocPos, const TRect& aClipRect) const

   796 	{

   797 	TTmHighlightExtensions highlightProperties;

   798 	highlightProperties.SetAll(0);

   799 	DrawSection(aGc,aTopLeft,aStartDocPos,aEndDocPos,aClipRect,highlightProperties,0,0);

   800 	}

   801 	

   802 /**

   803 Analogous to DrawSection(CGraphicsContext&, const TPoint&, TInt, TInt, const

   804 TRect&) but with highlight extensions applied.

   805 @see DrawSection(CGraphicsContext&, const TPoint&, TInt, TInt, const TRect&)

   806 @publishedPartner

   807 @released

   808 */

   809 EXPORT_C void CTmTextLayout::DrawSection(CGraphicsContext& aGc,

   810 	const TPoint& aTopLeft, TInt aStartDocPos, TInt aEndDocPos,

   811 	const TRect& aClipRect, const TTmHighlightExtensions& aHighlightExtensions,

   812 	TInt aHighlightStartDocPos, TInt aHighlightEndDocPos) const

   813 	{

   814 	// note: Assumes that RWindow::BeginRedraw() has been called by the caller.

   815 

   816 	TCursorSelection selection;

   817 	selection.SetSelection(aHighlightStartDocPos, aHighlightEndDocPos);

   818 

   819 	TRect boundingRect;

   820 	GetUpdateBoundingRect(aStartDocPos, aEndDocPos, aTopLeft, boundingRect);

   821 	if (! boundingRect.IsEmpty())

   822 		{

   823 		aHighlightExtensions.AbsExtendRect(boundingRect);

   824 		boundingRect.Intersection(aClipRect);

   825 		if (! boundingRect.IsEmpty())

   826 			{

   827 			DrawLayout(aGc, aTopLeft, boundingRect, NULL, ETrue, &selection, &aHighlightExtensions);

   828 			}

   829 		}

   830 	}

   831 

   832 /**

   833 Finds a document position and returns information about it and the line it is

   834 in.

   835 @param aDocPos The position to find.

   836 @param aPosInfo Returns information on the found position.

   837 @param aLineInfo Returns information on the line containing the position found.

   838 @return

   839 	True if the position was found within the formatted text. False if the

   840 	position was not in the formatted text.

   841 */

   842 EXPORT_C TBool CTmTextLayout::FindDocPos(const TTmDocPosSpec& aDocPos,

   843 	TTmPosInfo2& aPosInfo, TTmLineInfo& aLineInfo) const

   844 	{

   845 	if (!iSource)

   846 		return FALSE;

   847 	RTmGeneralInterpreter interpreter(*iSource, TTmInterpreterParam(*this));

   848 	TBool found = interpreter.FindDocPos(aDocPos,aPosInfo);

   849 	aLineInfo = interpreter.LineInfo();

   850 	interpreter.Close();

   851 	return found;

   852 	}

   853 

   854 /**

   855 Find a document position and return information about it and the line it is in. Return FALSE if the document

   856 position is outside the formatted text. The document position to be found is passed in aDocPos and the information

   857 about the position found is returned in aPosInfo. The line information is returned in aLineInfo.

   858 @deprecated 7.0s

   859 */

   860 EXPORT_C TBool CTmTextLayout::FindDocPos(const TTmDocPos& aDocPos,TTmPosInfo& aPosInfo,TTmLineInfo& aLineInfo) const

   861 	{

   862 	TTmDocPosSpec dp = aDocPos;

   863 	TTmPosInfo2 pi;

   864 	TBool r = FindDocPos(dp, pi, aLineInfo);

   865 	aPosInfo = pi;

   866 	return r;

   867 	}

   868 

   869 /**

   870 Finds a document position and returns information about it and the line it is

   871 in.

   872 @param aDocPos The position to find.

   873 @param aPosInfo Returns information on the found position.

   874 @param aLineInfo Returns information on the line containing the position found.

   875 @param aSubscript Returns the subscript height value.

   876 @return

   877 	True if the position was found within the formatted text. False if the

   878 	position was not in the formatted text.

   879 */

   880 EXPORT_C TBool CTmTextLayout::FindDocPos(const TTmDocPosSpec& aDocPos,

   881 	TTmPosInfo2& aPosInfo, TTmLineInfo& aLineInfo, TInt& aSubscript) const

   882 	{

   883 	if (!iSource)

   884 		return FALSE;

   885 	RTmGeneralInterpreter interpreter(*iSource, TTmInterpreterParam(*this));

   886 	TBool found = interpreter.FindDocPos(aDocPos,aPosInfo);

   887 	aLineInfo = interpreter.LineInfo();

   888 	aSubscript = interpreter.Subscript();

   889 	interpreter.Close();

   890 	return found;

   891 	}

   892 

   893 /**

   894 Finds a document position (i.e. the edge between two adjacent characters) by

   895 x-y position relative to the top-left corner of the formatted text.

   896 @param aXyPos Position to find.

   897 @param aPosInfo Returns information on the position closest to aXyPos.

   898 @param aLineInfo Returns information on the line containing aXyPos.

   899 @return

   900 	True if the Y-position is within the formatted text, or false otherwise.

   901 */

   902 EXPORT_C TBool CTmTextLayout::FindXyPos(const TPoint& aXyPos,

   903 	TTmPosInfo2& aPosInfo, TTmLineInfo& aLineInfo) const

   904 	{

   905 	if (!iSource)

   906 		return FALSE;

   907 	RTmGeneralInterpreter interpreter(*iSource, TTmInterpreterParam(*this));

   908 	TBool found = interpreter.FindXyPos(aXyPos,aPosInfo);

   909 	aLineInfo = interpreter.LineInfo();

   910 	interpreter.Close();

   911 	return found;

   912 	}

   913 

   914 /**

   915 Find an x-y position, relative to the top-left corner of the text, and return information about it and the line it is in.

   916 Return FALSE if the position is outside the formatted text. The document position to be found is passed in aDocPos and

   917 the information about the position found is returned in aPosInfo. The line information is returned in aLineInfo.

   918 @deprecated 7.0s

   919 */

   920 EXPORT_C TBool CTmTextLayout::FindXyPos(const TPoint& aXyPos,TTmPosInfo& aPosInfo,TTmLineInfo& aLineInfo) const

   921 	{

   922 	TTmPosInfo2 pi;

   923 	TBool r = FindXyPos(aXyPos, pi, aLineInfo);

   924 	aPosInfo = pi;

   925 	return r;

   926 	}

   927 

   928 /**

   929 Return the number of formatted lines.

   930 */

   931 EXPORT_C TInt CTmTextLayout::Lines() const

   932 	{

   933 	if (!iSource)

   934 		return 0;

   935 	TTmInterpreter interpreter(TTmInterpreterParam(*this));

   936 	return interpreter.Lines();

   937 	}

   938 

   939 /**

   940 Return the number of formatted paragraphs.

   941 */

   942 EXPORT_C TInt CTmTextLayout::Paragraphs() const

   943 	{

   944 	if (!iSource)

   945 		return 0;

   946 	TTmInterpreter interpreter(TTmInterpreterParam(*this));

   947 	return interpreter.Paragraphs();

   948 	}

   949 

   950 /**

   951 Returns information (including line number and formatting information) of the

   952 line containing a given document position.

   953 @param aDocPos Position to find.

   954 @param aLineInfo

   955 	Returns information about the line containing aDocPos if aDocPos is within

   956 	the formatted text, or an undefined value if not.

   957 @return True if the aDocPos was within the formatted text.

   958 */

   959 EXPORT_C TBool CTmTextLayout::DocPosToLine(const TTmDocPosSpec& aDocPos,

   960 	TTmLineInfo& aLineInfo) const

   961 	{

   962 	if (!iSource)

   963 		return FALSE;

   964 	TTmInterpreter interpreter(TTmInterpreterParam(*this));

   965 	TBool found = interpreter.DocPosToLine(aDocPos);

   966 	aLineInfo = interpreter.LineInfo();

   967 	return found;

   968 	}

   969 

   970 /**

   971 Retrieve information about the line containing a certain document position.

   972 Put information about the line containing aDocPos in aLineInfo. Return FALSE if aDocPos is not in the formatted text.

   973 @deprecated 7.0s

   974 */

   975 EXPORT_C TBool CTmTextLayout::DocPosToLine(const TTmDocPos& aDocPos,TTmLineInfo& aLineInfo) const

   976 	{

   977 	TTmDocPosSpec dp = aDocPos;

   978 	return DocPosToLine(dp, aLineInfo);

   979 	}

   980 

   981 /**

   982 Retrieve information about a line, referring to the line by its line number.

   983 

   984 Put information about the line numbered aLineNumber, counting the first formatted line as 0, in aLineInfo.

   985 Return FALSE if aLineNumber is not formatted.

   986 */

   987 EXPORT_C TBool CTmTextLayout::LineNumberToLine(TInt aLineNumber,TTmLineInfo& aLineInfo) const

   988 	{

   989 	if (!iSource)

   990 		return FALSE;

   991 	TTmInterpreter interpreter(TTmInterpreterParam(*this));

   992 	TBool found = interpreter.LineNumberToLine(aLineNumber);

   993 	aLineInfo = interpreter.LineInfo();

   994 	return found;

   995 	}

   996 

   997 /**

   998 Retrieve information about a line, referring to the line by its paragraph number and line number within the paragraph.

   999 

  1000 Put information about line aLineNumber in paragraph aParNumber, counting the first formatted paragraph as 0,

  1001 in aLineInfo. Return FALSE if aParNumber is not formatted. If aLineInPar is greater than the number of lines in

  1002 the paragraph the last line in the paragraph is returned.

  1003 */

  1004 EXPORT_C TBool CTmTextLayout::ParNumberToLine(TInt aParNumber,TInt aLineInPar,TTmLineInfo& aLineInfo) const

  1005 	{

  1006 	if (!iSource)

  1007 		return FALSE;

  1008 	TTmInterpreter interpreter(TTmInterpreterParam(*this));

  1009 	TBool found = interpreter.ParNumberToLine(aParNumber,aLineInPar);

  1010 	aLineInfo = interpreter.LineInfo();

  1011 	return found;

  1012 	}

  1013 

  1014 /**

  1015 Retrieve information about a line containing a certain y coordinate.

  1016 

  1017 Put information about the line containing the y coordinate aYPos, relative to 0 as the top of the formatted text, in

  1018 aLineInfo. Return FALSE if aYPos is outside all formatted lines.

  1019 */

  1020 EXPORT_C TBool CTmTextLayout::YPosToLine(TInt aYPos,TTmLineInfo& aLineInfo) const

  1021 	{

  1022 	if (!iSource)

  1023 		return FALSE;

  1024 	TTmInterpreter interpreter(TTmInterpreterParam(*this));

  1025 	TBool found = interpreter.YPosToLine(aYPos);

  1026 	aLineInfo = interpreter.LineInfo();

  1027 	return found;

  1028 	}

  1029 

  1030 

  1031 /**

  1032 Retrieve the text as displayed on a particular line.

  1033 

  1034 The text will be returned in display order, after all transformations have been

  1035 applied to the backing text. These transformations include bidirectional

  1036 reordering (making Arabic and Hebrew go right to left, etc.), ligation

  1037 (combining adjacent characters into a single glyph), suppressing control

  1038 characters, and converting characters to visible forms like visible spaces if

  1039 necessary.

  1040 

  1041 Precondition: SetTextL must have been called on this object before

  1042 GetDisplayedText can be called.

  1043 

  1044 Please note that any text that has passed through a shaper (for example

  1045 Devanagari text) will be replaced in the returned text with the Unicode

  1046 Replacement Character 0xFFFD. This is because the shaper produces glyph codes,

  1047 not Unicode characters, and this is because Unicode does not contain all the

  1048 ligatures and glyph variants required to display such scripts correctly.

  1049 

  1050 @param aLineNumber The line to fetch the display text of.

  1051 @param aText A buffer into which the display text is placed.

  1052 @param aNeeded

  1053 	Returns the number of characters in the displayed line. The text is

  1054 	truncated if aText is not big enough, aNeeded returns how large the buffer

  1055 	would need to be to return the whole line.

  1056 @return

  1057 	EFalse if the operation is impossible, perhaps because aLineNumber

  1058 is too large to be within the text.

  1059 @since 7.0

  1060 */

  1061 EXPORT_C TBool CTmTextLayout::GetDisplayedTextL(TInt aLineNumber, TDes& aText,

  1062 	TInt& aNeeded) const

  1063 	{

  1064 	__ASSERT_ALWAYS(iSource, TmPanic(ENoSource));

  1065 	RTmGeneralInterpreter interpreter(*iSource, TTmInterpreterParam(*this));

  1066 	CleanupClosePushL(interpreter);

  1067 	TBool result = interpreter.GetDisplayedTextL(aLineNumber, aText,0, aNeeded);

  1068 	CleanupStack::PopAndDestroy();

  1069 	return result;

  1070 	}

  1071 

  1072 /**

  1073 Retrieve the text as displayed on a particular line. Return FALSE if the operation is impossible (e.g., because no

  1074 MTmSource has yet been assigned). The text is returned in aText. The number of characters needed, which may be greater

  1075 than the size of aText, is placed in aNeeded.

  1076 

  1077 The text will be returned in display order, after all transformations have been applied to the backing text. These

  1078 transformations include bidirectional reordering (making Arabic and Hebrew go right to left, etc.), ligation (combining

  1079 adjacent characters into a single glyph), suppressing control characters, and converting characters to visible forms like

  1080 visible spaces if necessary.

  1081 @deprecated 7.0 It can fail due to environmental conditions, and should therefore be leavable. Use GetDisplayedTextL instead.

  1082 */

  1083 EXPORT_C TBool CTmTextLayout::GetDisplayedText(TInt aLineNumber,TDes& aText,TInt& aNeeded) const

  1084 	{

  1085 	if (!iSource)

  1086 		return FALSE;

  1087 	TBool result = EFalse;

  1088 	TRAPD(err, result = GetDisplayedTextL(aLineNumber, aText, aNeeded));

  1089     UNUSED_VAR(err);

  1090 	return result;

  1091 	}

  1092 

  1093 /**

  1094 Get the size of the minimal bounding box of the text when formatted to the specified wrap width.

  1095 The width may be greater than aWrapWidth. To find the minimum width for the text,

  1096 pass 0 for aWrapWidth. To find the minimum height, pass KMaxTInt for aWrapWidth.

  1097 */

  1098 EXPORT_C void CTmTextLayout::GetMinimumLayoutSizeL(TInt aWrapWidth,TSize& aSize) const

  1099 	{

  1100 		GetMinimumLayoutSizeL(aWrapWidth,ETrue,aSize);

  1101 	}

  1102 

  1103 /**

  1104 Get the size of the minimal bounding box of the text when formatted to the specified wrap width.

  1105 The width may be greater than aWrapWidth. To find the minimum width for the text,

  1106 pass 0 for aWrapWidth. To find the minimum height, pass KMaxTInt for aWrapWidth.

  1107 Use aAllowLegalLineBreaksOnly to set whether or not illegal line breaks should be considered

  1108 when determining aSize.

  1109 */

  1110 EXPORT_C void CTmTextLayout::GetMinimumLayoutSizeL(TInt aWrapWidth,TBool aAllowLegalLineBreaksOnly,TSize& aSize) const

  1111 	{

  1112 	if (!iSource)

  1113 		{

  1114 		aSize.iWidth = aSize.iHeight = 0;

  1115 		return;

  1116 		}

  1117 	TTmFormatParam param;

  1118 	param.iWrapWidth = aWrapWidth;

  1119 	param.iFlags = TTmFormatParam::EWrap;

  1120 	if(aAllowLegalLineBreaksOnly)

  1121 		param.iFlags |= TTmFormatParam::ELegalLineBreaksOnly;

  1122 	param.iStartChar = iStartChar;

  1123 	param.iEndChar = iEndChar;

  1124 	CTmCode* code = new(ELeave) CTmCode;

  1125 	CleanupStack::PushL(code);

  1126 	CTmFormatContext::TInfo info;

  1127 	

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

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

  1130 	TTmInterpreter interpreter(TTmInterpreterParam(*this));

  1131 	TBool lineFound = interpreter.DocPosToLine(startDocPos);

  1132 	if (lineFound)

  1133 		info.iContextCharPerLine = interpreter.LineContextCharChar();

  1134 	else