1 /*

     2 * Copyright (c) 1997-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 *

    16 */

    17 

    18 

    19 #include <e32std.h>

    20 #include <e32base.h>

    21 

    22 #include <gdi.h>

    23 #include <s32stor.h>

    24 #include "TXTFMLYR.H"

    25 #include "TXTETEXT.H"

    26 #include "TXTLAYDC.H"

    27 #include "TXTSTYLE.H"

    28 #include "TXTINDEX.H"

    29 

    30 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    31 #include "TXTFMLYR_INTERNAL.H"

    32 #include "TXTSTYLE_INTERNAL.H"

    33 #endif

    34 

    35 TGlobalLayerInfoAppend::TGlobalLayerInfoAppend()

    36 	: iAggParaFormatLayer(NULL),iAggCharFormatLayer(NULL),iComParaFormatLayer(NULL),iComCharFormatLayer(NULL)

    37 	{}

    38 

    39 TGlobalLayerInfoAppend::TGlobalLayerInfoAppend(const CParaFormatLayer* aAggParaFormatLayer,const CCharFormatLayer* aAggCharFormatLayer,

    40 							const CParaFormatLayer* aComParaFormatLayer,const CCharFormatLayer* aComCharFormatLayer)

    41 	: iAggParaFormatLayer(aAggParaFormatLayer),iAggCharFormatLayer(aAggCharFormatLayer),

    42 	  iComParaFormatLayer(aComParaFormatLayer),iComCharFormatLayer(aComCharFormatLayer)

    43 	{}

    44 

    45 

    46 TTextFragment::TTextFragment():

    47 	iLength(0),

    48 	iPhraseCount(0)

    49 	{

    50 	}

    51 

    52 

    53 TCurrentIndexRecords::TCurrentIndexRecords()

    54 	{

    55 	}

    56 

    57 

    58 DLLEXPORT_C void CRichTextIndex::__DbgTestInvariant()const

    59 // Provides class invariants.  Explanations below:

    60 //

    61 	{

    62 #ifdef _DEBUG

    63 // ASSERT: Every phrase index is consistent with its corresponding paragraph.

    64 	TInt zeroLengthPhraseCount=0;

    65 	TInt maxPara=iParaIx->Count();

    66 	TInt numberOfReferencesToSharedList=0;

    67 	TInt currentPhraseElement=0;

    68 	for (TInt para=0;para<maxPara;para++)

    69 		{

    70 		// ASSERT: The basedOn link is valid.

    71 		CFormatLayer* thisLayer=(*iParaIx)[para].iParaAttribs->iParaFormat;

    72 		CFormatLayer* base=CONST_CAST(CFormatLayer*,thisLayer->SenseBase());

    73 		__ASSERT_DEBUG(base!=NULL,User::Invariant());

    74 		if ((*iParaIx)[para].iParaAttribs->iRefCount>0)

    75 			numberOfReferencesToSharedList++;

    76 		TInt paragraphLength=(*iParaIx)[para].iLength;

    77 		TInt sumOfPhraseLengths=0;

    78 		TInt maxPhrase=(*iParaIx)[para].iParaAttribs->PhraseCount();

    79 		for (TInt phrase=0;phrase<maxPhrase;phrase++)

    80 			{

    81 			if (maxPhrase>1)

    82 				{

    83 				const RPhraseAttribsEntry* phrase=&(*iPhraseIx)[currentPhraseElement];

    84 				CCharFormatLayer* charFormatLayer=phrase->CharFormat();

    85 				// ASSERT: The basedOn link is valid.

    86 				__ASSERT_DEBUG(charFormatLayer->SenseBase()!=NULL,User::Invariant());

    87 				__ASSERT_DEBUG(TInt(charFormatLayer->SenseBase())>0x1000,User::Invariant());

    88 				sumOfPhraseLengths+=(*iPhraseIx)[currentPhraseElement].Length();

    89 				if ((*iPhraseIx)[currentPhraseElement].Length()==0)

    90 					zeroLengthPhraseCount++;

    91 				currentPhraseElement++;

    92 				}

    93 			else

    94 				{

    95 				CCharFormatLayer* charFormatLayer=(*iParaIx)[para].iParaAttribs->iCharFormat;

    96 				// ASSERT: The basedOn link is valid.

    97 				__ASSERT_DEBUG(charFormatLayer->SenseBase()!=NULL,User::Invariant());

    98 				sumOfPhraseLengths+=(*iParaIx)[para].iLength;

    99 				}

   100 			}

   101 		__ASSERT_DEBUG(sumOfPhraseLengths==paragraphLength,User::Invariant());

   102 		}

   103 // ASSERT: We have no unexpected phrases left over

   104 	__ASSERT_DEBUG(currentPhraseElement==-1 ||

   105 					currentPhraseElement==iPhraseIx->Count(),User::Invariant());

   106 // ASSERT: There is either zero(0) or one(1) zero length phrase in the whole index

   107 	__ASSERT_DEBUG( (zeroLengthPhraseCount==0) ||

   108 					(zeroLengthPhraseCount==1 && iPendingNewPhrasePos!=EInsertCharFormatReset),

   109 					User::Invariant());

   110 // ASSERT: the number of paraEntries with paraAttribs of refCount>0 == the sum of refCounts in the shared list.

   111 //			or is only one less - as is set when SetInsertCharFormat is called on a shared paraAttribs.

   112 	TInt totalReferenceCount=0;

   113 	if (!iSharedParaQueHead.IsEmpty())

   114 		{

   115 		CParaAttribs* currentSharedPara;

   116 		TDblQueIter<CParaAttribs> iterator(((CRichTextIndex*)this)->iSharedParaQueHead);

   117 		while ((currentSharedPara=iterator++)!=NULL)

   118 			totalReferenceCount+=currentSharedPara->iRefCount;

   119 		}

   120 	__ASSERT_DEBUG((numberOfReferencesToSharedList==totalReferenceCount) ||

   121 				   (numberOfReferencesToSharedList==totalReferenceCount-1),User::Invariant());

   122 // ASSERT: iPictureCount corresponds to the number of pictures in the stored in the index.

   123 	TInt picCount=0;

   124 	TInt phraseCount=(iPhraseIx) ? iPhraseIx->Count() : 0;

   125 	for (TInt item=0;item<phraseCount;item++)

   126 		picCount+=((*iPhraseIx)[item].IsPicturePhrase())

   127 					? 1

   128 					: 0;

   129 	__ASSERT_DEBUG(iPictureCount==picCount,User::Invariant());

   130 #endif

   131 	}

   132 

   133 

   134 CRichTextIndex* CRichTextIndex::NewL(const CParaFormatLayer* aGlobalParaLayer,const CCharFormatLayer* aGlobalCharLayer,

   135 									 const CRichText& aText,TInt aParaGran,TInt aPhraseGran)

   136 // Return a handle to a new instance of this class.

   137 // Requires the global format layer handles on which to base the first content.

   138 //

   139 	{

   140 	CRichTextIndex* self=new(ELeave) CRichTextIndex(aText);

   141 	CleanupStack::PushL(self);

   142 	self->ConstructL(aGlobalParaLayer,aGlobalCharLayer,aParaGran,aPhraseGran);

   143 	CleanupStack::Pop();

   144 	return self;

   145 	}

   146 

   147 

   148 CRichTextIndex::CRichTextIndex(const CRichText& aText):

   149 	iText(aText),

   150 	iPendingNewPhrasePos(EInsertCharFormatReset),

   151 	iSharedParaQueHead(_FOFF(CParaAttribs,link))

   152 	{

   153 	}

   154 

   155 

   156 void CRichTextIndex::ConstructL(const CParaFormatLayer* aGlobalParaLayer,const CCharFormatLayer* aGlobalCharLayer,TInt aParaGran,TInt aPhraseGran)

   157 // Provides a fully initialised rich text index.

   158 // Upon construction, the index contains a single paragraph of length 1 (para.terminator).

   159 // This first paragraph initially has constant character formatting, ie the shared para list

   160 // must have one item in it.

   161 //

   162 	{

   163 	CParaFormatLayer* paraLayer=CParaFormatLayer::NewL();  // Creates empty layer.

   164 	paraLayer->SetBase(aGlobalParaLayer);  // Sets basedOn to global default.

   165 	CleanupStack::PushL(paraLayer);

   166 	CCharFormatLayer* charLayer=CCharFormatLayer::NewL();  // Creates empty layer.

   167 	charLayer->SetBase(aGlobalCharLayer);  // Sets basedOn to global default.

   168 	CleanupStack::PushL(charLayer);

   169 	CParaAttribs* paraAttribs=GetParaAttribsL(paraLayer,charLayer);

   170 	CleanupStack::PopAndDestroy(2);

   171 	CleanupStack::PushL(TCleanupItem(ReleaseOnCleanup,paraAttribs));

   172 	iParaIx=new(ELeave) CArrayFixSeg<TParaAttribsEntry>(aParaGran);

   173 	TParaAttribsEntry para(1,paraAttribs);

   174 	iParaIx->AppendL(para);

   175 	CleanupStack::Pop();

   176 	iPhraseIx=new(ELeave) CArrayFixSeg<RPhraseAttribsEntry>(aPhraseGran);

   177 

   178 	__TEST_INVARIANT;

   179 	}

   180 

   181 

   182 CRichTextIndex::~CRichTextIndex()

   183 // Free up all storage allocated in the rich text index.

   184 //

   185 	{

   186 	TInt count;

   187 	if (iPhraseIx)

   188 		{// Destroy the phrase index and its contents.

   189 		__ASSERT_ALWAYS(iParaIx,Panic(EPhraseIxPresentWithNoParaIx));

   190 		count=iPhraseIx->Count();

   191 		for (TInt offset=0;offset<count;offset++)

   192 			(*iPhraseIx)[offset].Discard();

   193 		}

   194 	delete iPhraseIx;

   195 	if (iParaIx)

   196 		{// Destroy the para index and its contents.

   197 		count=iParaIx->Count();

   198 		for (TInt offset=0;offset<count;offset++)

   199 			{

   200 			CParaAttribs* pA=(*iParaIx)[offset].iParaAttribs;

   201 			if (!pA->IsShared())

   202 				pA->Release();

   203 			}

   204 		}

   205 	delete iParaIx;

   206 	RebalanceIndex();

   207 	//

   208 	// Clear the shared list.  (Will usually be empty by now

   209 	// unless internalize failed after getting shared list & before getting all para data.

   210 	CParaAttribs* currentSharedPara;

   211 	TDblQueIter<CParaAttribs> iterator(iSharedParaQueHead);

   212 	while ((currentSharedPara=iterator++)!=NULL)

   213 		currentSharedPara->Release(currentSharedPara->iRefCount);

   214 	__ASSERT_ALWAYS(iSharedParaQueHead.IsEmpty(),Panic(ERichTextIndexIntegrityErr));

   215 	}

   216 

   217 

   218 TInt CRichTextIndex::CharPosOfParagraph(TInt& aLength,TInt aParaOffset)const

   219 // Returns the character position of the first character of paragraph aParaOffset,

   220 // where aParaOffset specifies the nth paragraph.

   221 // The length of this nth paragraph is written to aLength.

   222 //

   223 // If aParaOffset specifies a paragraph that does not exist, EScanEndOfData is returned.

   224 //

   225 	{

   226 	__TEST_INVARIANT;

   227 

   228 	if (aParaOffset>=iParaIx->Count())

   229 		return CPlainText::EScanEndOfData;

   230 	TInt pos=0,offset=0;

   231 	for (offset=0;offset<aParaOffset;offset++)

   232 		pos+=(*iParaIx)[offset].iLength;

   233 	aLength=(*iParaIx)[offset].iLength;

   234 	return pos;

   235 	}

   236 

   237 

   238 TInt CRichTextIndex::ParagraphNumberForPos(TInt& aPos)const

   239 // Returns the paragraph offset for the specified character position aPos.

   240 // aPos is in turn modified to hold the character position of the first character

   241 // of this paragraph.  If aPos is already on a paragraph boundary then do nothing.

   242 //

   243 	{

   244 	__TEST_INVARIANT;

   245 

   246 	((CRichTextIndex*)this)->ScanToPosition(aPos,EScanToPositionAbsolute);

   247 	aPos-=iPos.iParaElementOffset;

   248 	return iPos.iParaElement;

   249 	}

   250 

   251 

   252 void CRichTextIndex::DocumentChanged()const

   253 	{

   254  	MUTABLE_CAST(TLogicalPosition&,iLastUsed).Clear();

   255 	}

   256 

   257 

   258 void CRichTextIndex::DoSoloInsertL(TInt aPos,TInt aLength)

   259 // Updates the index following the insertion of content into a single phrase.

   260 // First find the phrase record the governs the insert pos.

   261 // (1) If the current phrase is a text phrase, then simply extend the length of the phrase record.

   262 // (2) If the current phrase is a picture phrase then this cannot be extended.

   263 // There is 1 pathological case here:

   264 // (i) The [current] picture phrase is the 1st phrase in the paragraph, and the insert pos

   265 // is before this phrase. (paragraph insert pos == 0).

   266 // In this case we must insert a new text phrase *before* the picture phrase.

   267 // (ii) In normal circumstances the inserted text is after the picture phrase.  So, if the

   268 // following phrase is of the same character format as the picture then we can re-use this phrase.

   269 // If it is not of the same character format (or is also a picture phrase),

   270 // then we must insert a new text phrase of the correct format immediately following the current picture phrase.

   271 //

   272 	{

   273 	RebalanceIndex();

   274 	if (!((iPendingNewPhrasePos == EInsertCharFormatReset) || (aPos == iPendingNewPhrasePos)))

   275 		CancelInsertCharFormat();

   276 

   277 	ScanToPosition(aPos,EScanToPositionMatchLeft);

   278 	TCurrentIndexRecords current; GetCurrentRecords(current);

   279 	if (current.iPhrase && current.iPhrase->IsPicturePhrase())

   280 		{// Paragraph has specific char format, and current phrase is picture phrase.

   281 		TInt newPhraseRequired=EFalse;

   282 		CCharFormatLayer* charLayer=current.iPhrase->CharFormat();

   283 		if (FirstPhraseOfParagraph() && iPos.iPhraseElementOffset==0)

   284 			newPhraseRequired=ETrue;  // Text is inserted at the start of the para behind the picture.

   285 		else

   286 			{// Check for re-use of the next text phrase.

   287 			iPos.iPhraseElement++;

   288 			iPos.iPhraseElementOffset=0;

   289 			const RPhraseAttribsEntry& nextPhrase=(*iPhraseIx)[iPos.iPhraseElement];

   290 			if (nextPhrase.IsPicturePhrase() || !nextPhrase.CharFormat()->IsIdentical(charLayer,EFalse))

   291 				{// Need a new phrase if the formats don't match OR the next phrase is a picture phrase.

   292 				newPhraseRequired=ETrue;  // Need to create a new phrase to take this insert.

   293 				}

   294 			}

   295 		if (newPhraseRequired)

   296 			{// Insert new phrase & record this fact

   297 			CCharFormatLayer* charFormat=CCharFormatLayer::NewCopyBaseL(charLayer);

   298 			RPhraseAttribsEntry newPhrase(charFormat);

   299 			CleanupStack::PushL(charFormat);

   300 			iPhraseIx->InsertL(iPos.iPhraseElement,newPhrase);

   301 			CleanupStack::Pop();

   302 			current.iParaAttribs->iPhraseCount++;

   303 			}

   304 		GetCurrentRecords(current);  // Update current records, cos used below.

   305 		}

   306 	// Extend the lengths in the index.

   307 	current.iParaEntry->iLength+=aLength;  // Increase length of paragraph.

   308 	if (current.iPhrase)

   309 		current.iPhrase->AdjustLength(aLength);  // Increase the length of this phrase.

   310 	iPos.iPhraseElementOffset+=aLength;

   311 	iPos.iParaElementOffset+=aLength;

   312 	iPos.iDocPos+=aLength;

   313 	}

   314 

   315 

   316 void CRichTextIndex::InsertL(TInt aPos,const TDesC& aBuf,const CParaFormatLayer& aGlobalParaFormatLayer)

   317 // Updates the index following the insertion of a descriptor of text into the document.

   318 // Correctly handles embedded paragraph delimiters.

   319 //

   320 	{

   321 	__TEST_INVARIANT;

   322 	TInt bufLen=aBuf.Length();

   323 

   324 	RebalanceIndex();

   325 	TInt paragraphCount=0;

   326 	const TText* start=aBuf.Ptr();

   327 	const TText* end=start+bufLen;

   328 	while (start<end)

   329 		{

   330 		if (*start++==CEditableText::EParagraphDelimiter)

   331 			paragraphCount++;

   332 		}

   333 	if (paragraphCount==0)

   334 		{

   335 		if (bufLen > 0)

   336 			{

   337 			DoSoloInsertL(aPos,bufLen);

   338 			CancelInsertCharFormat();

   339 			}

   340 		__TEST_INVARIANT;

   341 		return;

   342 		}

   343 	ScanToPosition(aPos,EScanToPositionMatchLeft);

   344 	TLogicalPosition pastePos=iPos;  // Used to adjust paragraph/phrase lengths later

   345 

   346 	if (paragraphCount>1)

   347 		{

   348 		TCurrentIndexRecords current;

   349 		GetCurrentRecords(current);

   350 		const CParaAttribs& paraAttribs=*current.iParaAttribs;

   351 		CCharFormatLayer* charLayer=(paraAttribs.IsShared())

   352 								? paraAttribs.iCharFormat

   353 								: (*iPhraseIx)[iPos.iPhraseElement].CharFormat();

   354 		CParaFormatLayer* paraLayer=paraAttribs.iParaFormat;

   355 		CParaAttribs* theParaAttribs=GetParaAttribsL(paraLayer,charLayer);

   356 		CleanupStack::PushL(TCleanupItem(ReleaseOnCleanup,theParaAttribs));

   357 		iParaIx->InsertL(pastePos.iParaElement,TParaAttribsEntry(0,theParaAttribs),paragraphCount-1);

   358 		CleanupStack::Pop();

   359 		theParaAttribs->iRefCount+=paragraphCount-2;	// add the extra references

   360 		}

   361 	TLogicalPosition pos;

   362 	TRAPD(ret,

   363 	SplitParagraphAtPastePosL(pastePos,pos,aGlobalParaFormatLayer));

   364 		if (ret!=KErrNone)

   365 			{

   366 			RbRemoveInsertedParaAttribsEntries(pastePos.iParaElement,paragraphCount-1);

   367 			User::Leave(ret);

   368 			}

   369 

   370 	if (paragraphCount>1)

   371 		{	// swap the entries for the split and first inserted paragraph

   372 		TParaAttribsEntry& paraEntry=(*iParaIx)[pastePos.iParaElement+paragraphCount-1];

   373 		TParaAttribsEntry& insertEntry=(*iParaIx)[pastePos.iParaElement];

   374 		TParaAttribsEntry temp=paraEntry;

   375 		paraEntry=insertEntry;

   376 		insertEntry=temp;

   377 		}// Cos weve inserted new paragraphs in front of the governing one.

   378 

   379 	// Sort out the front para

   380 	TParaAttribsEntry& frontPara=(*iParaIx)[pastePos.iParaElement];

   381 	TPtrC buf(aBuf);

   382 	TInt lengthOfFirstPara=ParaLengthFromBuffer(buf);

   383 	frontPara.iLength+=lengthOfFirstPara;  // Adjust the para length

   384 	buf.Set(aBuf.Right(aBuf.Length()-lengthOfFirstPara-1));

   385 	if (!frontPara.iParaAttribs->IsShared() && lengthOfFirstPara != 0)

   386 		{

   387 		RPhraseAttribsEntry* phrase=&(*iPhraseIx)[pastePos.iPhraseElement];

   388 		if (phrase->IsPicturePhrase())

   389 			{	// move insertion past any picture phrase

   390 			pastePos.iPhraseElement++;

   391 			pastePos.iPhraseElementOffset=0;

   392 			phrase=&(*iPhraseIx)[pastePos.iPhraseElement];

   393 			}

   394 		phrase->AdjustLength(lengthOfFirstPara);  // Adjust the phrase length

   395 		}

   396 	for (TInt paraItem=1;paraItem<paragraphCount;paraItem++)

   397 		{// For each para inserted between the fist and last

   398 		TParaAttribsEntry& para=(*iParaIx)[pastePos.iParaElement+paraItem];

   399 		TInt length=ParaLengthFromBuffer(buf)+1;

   400 		__ASSERT_DEBUG(length!=KErrNotFound,Panic(EInsertEmbeddedParaErr));

   401 		para.iLength=length;

   402 		buf.Set(buf.Right(buf.Length()-length));

   403 		}

   404 	// For final paragrph

   405 	TInt trailingTextLen=buf.Length();

   406 	if (trailingTextLen>0)

   407 		{

   408 		TParaAttribsEntry& backPara=(*iParaIx)[pos.iParaElement];

   409 		backPara.iLength+=trailingTextLen;

   410 		if (!backPara.iParaAttribs->IsShared())

   411 			{

   412 			RPhraseAttribsEntry& phrase=(*iPhraseIx)[pos.iPhraseElement];

   413 			phrase.AdjustLength(trailingTextLen);  // Adjust phrase length

   414 			}

   415 		}

   416 	//

   417 	// Now tidy up

   418 	if (bufLen>1 && iPendingNewPhrasePos!=EInsertCharFormatReset)

   419 		{

   420 		iPendingNewPhrasePos=aPos+(bufLen-trailingTextLen);

   421 		CancelInsertCharFormat();

   422 		}

   423 

   424 	__TEST_INVARIANT;

   425 	}

   426 

   427 

   428 void CRichTextIndex::SplitParagraphAtPastePosL(TLogicalPosition& aPastePos,TLogicalPosition& aNewPos,

   429 												const CParaFormatLayer& aGlobalParaFormatLayer)

   430 // Breaks the paragraph specified by the logical position aPastePos, inserting a paragraph delimiter.

   431 //

   432 	{

   433 	TInt insertPendingPos = iPendingNewPhrasePos;

   434 	DoSoloInsertL(aPastePos.iDocPos,1);

   435 	TBool insertCharFormatDeleted = EFalse;

   436 	if (InsertCharFormatIsActive())

   437 		{

   438 		insertCharFormatDeleted = DeleteInsertCharFormat();

   439 		iPendingNewPhrasePos = EInsertCharFormatReset;

   440 		}

   441 	TRAPD(ret,

   442 	InsertParagraphL(aPastePos.iDocPos+1,aGlobalParaFormatLayer));  // Split the current para (and maybe phrase index).

   443 	if (ret!=KErrNone)

   444 		{

   445 		// locate the character inserted by DoSoloInsertL() above

   446 		ScanToPosition(aPastePos.iDocPos,EScanToPositionAbsolute);

   447 		TCurrentIndexRecords current;

   448 		GetCurrentRecords(current);

   449 		current.iParaEntry->iLength--;

   450 		if (current.iPhrase)

   451 			{

   452 			current.iPhrase->AdjustLength(-1);  // collapse phrase by right amount

   453 			if (insertPendingPos!=EInsertCharFormatReset)

   454 				{

   455 				__ASSERT_DEBUG(current.iPhrase->Length()==0,User::Invariant());

   456 				iPendingNewPhrasePos=insertPendingPos;

   457 				}

   458 			else if (current.iPhrase->Length()==0)

   459 				{

   460 				RemoveFromPhraseIx(iPos.iPhraseElement,1);

   461 				current.iParaAttribs->iPhraseCount--;

   462 				__ASSERT_DEBUG(current.iParaAttribs->PhraseCount()>1,User::Invariant());

   463 				}

   464 			}

   465 		User::Leave(ret);

   466 		}

   467 	if (insertPendingPos != EInsertCharFormatReset)

   468 		ConsolidateAt(insertPendingPos, insertCharFormatDeleted?

   469 			EPositionOnly : EFollowingPhrase);

   470 	ScanToPosition(aPastePos.iDocPos+1,EScanToPositionMatchLeft);  // Gives us the next para.

   471 	aNewPos=iPos;

   472 	}

   473 

   474 

   475 TInt CRichTextIndex::ParaLengthFromBuffer(TDesC& aBuf)const

   476 // Returns the length of the first para found in the buffer.

   477 // The returned length excludes the paragraph delimiter character.

   478 // Returns KNotFound if there is no paragraph delimiter.

   479 //

   480 	{return aBuf.Locate(CEditableText::EParagraphDelimiter);}

   481 

   482 

   483 void CRichTextIndex::InsertL(TInt aPos,const TPictureHeader& aPicHdr, TBool& aPictureOwnershipTaken)

   484 // Updates the index following the insertion of a picture header object into the text

   485 // component.  This is accomplished by creating & inserting a picture phrase at the

   486 // relevant place.

   487 //

   488 	{

   489 	__TEST_INVARIANT;

   490 

   491 	RebalanceIndex();

   492 // ASSERT: A valid picture header, referencing a valid picture has been inserted.

   493 	__ASSERT_ALWAYS(aPicHdr.iPicture.IsPtr() && aPicHdr.iPicture.AsPtr()!=NULL,Panic(EInsertNullPicHdrData));

   494 // ASSERT: The current insert pos hasn't been changed without cancelling SetInsertCharFormat.

   495 	__ASSERT_ALWAYS((iPendingNewPhrasePos==EInsertCharFormatReset) || (aPos==iPendingNewPhrasePos),

   496 					Panic(ESetInsertCharFormatIntegrityErr));

   497 	if (iPendingNewPhrasePos!=EInsertCharFormatReset)

   498 		CancelInsertCharFormat();  // Cancel this state before inserting picture. Rebalances the index.

   499 	ScanToPosition(aPos,EScanToPositionMatchLeft);

   500 	TCurrentIndexRecords current; GetCurrentRecords(current);

   501 	TCharFormatX format;

   502 	TCharFormatXMask mask;  //...and build up its format.

   503 	CCharFormatLayer* baseChar;

   504 	GetPhraseFormat(current,format,mask,baseChar);  //...inherit format from prev. phrase.

   505 	// Create the picture phrase. Takes ownership of the aPicHdr.iPicture

   506 	CPicturePhrase* picture=CPicturePhrase::NewL(aPicHdr,format,mask,baseChar,aPictureOwnershipTaken);

   507 	CleanupStack::PushL(picture);

   508 	//New reclaimed CParaAttribs instance

   509 	CParaAttribs* reclaimed=RequestReclaimShareL(current.iParaAttribs,current.iParaEntry);

   510     //Store the old CParaAttribs instance in rollbackParaAttribsHandle

   511 	CParaAttribs* rollbackParaAttribsHandle=current.iParaAttribs;

   512 	if (reclaimed)

   513 		{

   514 		CleanupStack::PushL(TCleanupItem(ReleaseOnCleanup,reclaimed));

   515 		current.iParaEntry->iParaAttribs=reclaimed;  // Use this reclaimed para attribs (the new CParaAttribs instance)

   516 		}

   517 	GetCurrentRecords(current);

   518 //	ASSERT: The reclaim succeeded.  We must always end up with a PhraseIx-not constant char format.

   519 	__ASSERT_DEBUG(current.iPhrase!=NULL,Panic(EReclaimShareError));

   520 	TRAPD(ret1,

   521 	SplitPhraseL(aPos));  // Phrase may not be split if at boundary.

   522 

   523     if (ret1!=KErrNone)

   524         {

   525         RbInsertPicture(rollbackParaAttribsHandle);//Restore the old CParaAttribs instance

   526         User::Leave(ret1);

   527         }

   528 

   529 	TInt offset=(PhraseSplit())?1:0;  // Insert position of new phrase relative to current.

   530 	RPhraseAttribsEntry newPhrase(picture);

   531 	TRAPD(ret2,

   532 	iPhraseIx->InsertL(iPos.iPhraseElement+offset,newPhrase));

   533     if (ret2!=KErrNone)

   534         {

   535         RbInsertPicture(rollbackParaAttribsHandle);//Restore the old CParaAttribs instance

   536         User::Leave(ret2);

   537         }

   538 

   539 	if(reclaimed)

   540 	    {

   541         CleanupStack::Pop();//"Pop" for CleanupStack::PushL(TCleanupItem(ReleaseOnCleanup,reclaimed));

   542 	    }

   543 	CleanupStack::Pop(picture);

   544 	// Update counts etc. - cannot leave now.

   545 	current.iParaEntry->iLength+=RPhraseAttribsEntry::EPicturePhraseLength;

   546 	current.iParaAttribs->iPhraseCount++;  // for the picture phrase

   547 	iPictureCount++;

   548 

   549 	// Commit

   550 	if(reclaimed)

   551 	    {

   552         rollbackParaAttribsHandle->Release();  // Release hold on original shared paraAttribs.

   553 	    }

   554 

   555 	__TEST_INVARIANT;

   556 	//coverity[memory_leak]

   557 	}

   558 

   559 void CRichTextIndex::RbInsertPicture(CParaAttribs* aGoodParaAttribs)

   560 // Reinstate the original good paraAttribs.

   561 // Then rollback the SplitPhrase() call if it succeeded.

   562 //

   563 	{

   564 	(*iParaIx)[iPos.iParaElement].iParaAttribs=aGoodParaAttribs;

   565 	if (PhraseSplit())

   566 		{// Rollback the SplitPhrase()

   567 		TInt length=(*iPhraseIx)[iPos.iPhraseElement+1].Length();

   568 		RemoveFromPhraseIx(iPos.iPhraseElement+1);

   569 		(*iPhraseIx)[iPos.iPhraseElement].AdjustLength(length);

   570 		}

   571 	}

   572 

   573 

   574 // Insert a new paragraph immediately following character position aPos, fixing the length of the preceeding

   575 // paragraph.  The new paragraph preserves any explicit paragraph/character formatting, and is based on the

   576 // global layers.  (Do not need to rebalance the index here; a previous call to DoSoloInsertL accomplishes this)

   577 

   578 void CRichTextIndex::InsertParagraphL(TInt aPos,const CParaFormatLayer& aGlobalParaFormatLayer)

   579 	{

   580 	ScanToPosition(aPos,EScanToPositionMatchLeft);

   581 	TCurrentIndexRecords current;

   582 	GetCurrentRecords(current);

   583 	TParaAttribsEntry newPara;

   584 	CCharFormatLayer* charLayer;

   585   	if (current.iPhrase)  // entry in phrase index

   586 		charLayer=current.iPhrase->CharFormat();

   587 	else

   588 		charLayer=current.iParaAttribs->iCharFormat;

   589 	//

   590 	// New para format layer, based on normal, inheriting specific format

   591 	CParaFormatLayer* currentParaFormat=current.iParaAttribs->iParaFormat;

   592 	CParaFormatLayer* newParaLayer=CParaFormatLayer::NewL(currentParaFormat);

   593 	const CParaFormatLayer& currentStyle=STATIC_CAST(const CParaFormatLayer&,*currentParaFormat->SenseBase());

   594 	const TUid currentStyleType=currentStyle.Type();

   595 

   596 	// !!

   597 	// Only change to Normal if current style is a built-in one

   598 	// or we are not at the end of a heading style.

   599 	TBool useNormal;

   600 	if (currentStyleType==KNormalParagraphStyleUid)

   601 		useNormal=ETrue;

   602 	else if (currentStyleType==KUserDefinedParagraphStyleUid)

   603 		useNormal=EFalse;

   604 	else if (iPos.iParaElementOffset<=(current.iParaEntry->iLength-2))  // cos of previous call to DoSoloInsertL()

   605 		useNormal=EFalse;

   606 	else

   607 		useNormal=ETrue;

   608 	newParaLayer->SetBase((useNormal)

   609 		? &aGlobalParaFormatLayer

   610 		: &currentStyle);

   611 	const CCharFormatLayer* newCharBase=(useNormal)

   612 		? iText.GlobalCharFormatLayer()

   613 		: STATIC_CAST(const CParagraphStyle&,currentStyle).CharFormatLayer();

   614 	CleanupStack::PushL(newParaLayer);

   615 	//

   616 	if (current.iParaAttribs->IsShared())

   617 		{// Current para has constant char format - so the new one also has constant char format

   618 		// New char format layer, based on normal, inheriting specific format

   619 		CCharFormatLayer* newCharLayer=CCharFormatLayer::NewL(charLayer);

   620 		newCharLayer->SetBase(newCharBase);

   621 		CleanupStack::PushL(newCharLayer);

   622 		newPara.iParaAttribs=GetParaAttribsL(newParaLayer,newCharLayer);

   623 		CleanupStack::PopAndDestroy(2);  // newCharLayer/newParaLayer

   624 		CleanupStack::PushL(TCleanupItem(ReleaseOnCleanup,newPara.iParaAttribs));

   625 		iParaIx->InsertL(iPos.iParaElement+1,newPara);

   626 		CleanupStack::Pop();  // paraAttribs cleanup item

   627 		GetCurrentRecords(current);		// could be changed by InsertL() above

   628 		}

   629 	else  // Do the split myself since this para has specific character formatting.

   630 		{// Make the new CParaAttribs

   631 		CParaAttribs* newParaAttribs=CParaAttribs::NewL(newParaLayer);

   632 		CleanupStack::PopAndDestroy();  // newParaLayer - copy owned by newParaAttribs

   633 		CleanupStack::PushL(TCleanupItem(ReleaseOnCleanup,newParaAttribs));

   634 		//

   635 		// Split current phrase & insert if necessary.

   636 		// Split even when we are at a phrase boundary -> this introduces an z.l.p. for the insertion point

   637 		RPhraseAttribsEntry& insertPhrase=iPhraseIx->At(iPos.iPhraseElement);

   638 		TInt insertPendingPos=(iPos.iPhraseElementOffset==insertPhrase.Length()) ? aPos : EInsertCharFormatReset;

   639 		DoSplitPhraseL(insertPhrase,iPos.iPhraseElementOffset,current.iParaAttribs);  // Ups iPhraseCount

   640 		//

   641 		// Insert the new paragraph.

   642 		newPara.iParaAttribs=newParaAttribs;

   643 		TRAPD(ret,

   644 		iParaIx->InsertL(iPos.iParaElement+1,newPara));  // Inserts the new paraAttribsEntry record.

   645 			if (ret!=KErrNone)

   646 				{

   647 				RemoveFromPhraseIx(iPos.iPhraseElement+1,1);	// inserted by DoSplitPhraseL

   648 				current.iParaAttribs->iPhraseCount--;

   649 				User::Leave(ret);

   650 				}

   651 

   652 		iPendingNewPhrasePos=insertPendingPos;

   653 		CleanupStack::Pop();			// newParaAttribs. All OK now

   654 		GetCurrentRecords(current);		// could be changed by InsertL() above

   655 		//

   656 		// Calculate new paraAttribs phrase counts.

   657 		TInt remainder=(iPos.iPhraseElement+1)-iPos.iParaBasePhraseElement;

   658 		TInt newPhraseCount=current.iParaAttribs->iPhraseCount-remainder;

   659 		newParaAttribs->iPhraseCount=newPhraseCount;

   660 		current.iParaAttribs->iPhraseCount=remainder;

   661 

   662 		const CArrayFix<RPhraseAttribsEntry>& phraseIx=*iPhraseIx;

   663 		TInt startPhrase=iPos.iPhraseElement+1;

   664 		for (TInt ii=startPhrase; ii<startPhrase+newPhraseCount; ii++)

   665 			{

   666 			RPhraseAttribsEntry phrase=phraseIx[ii];

   667 			phrase.CharFormat()->SetBase(newCharBase);

   668 			}

   669 		//

   670 		// The index now reflects the correct state.

   671 		// Next, the efficiency thing - see if the new paras can share existing ones.

   672 		if (newPhraseCount==1)

   673 			Share(iParaIx->At(iPos.iParaElement+1),iPos.iParaBasePhraseElement+remainder);

   674 		if (remainder==1)

   675 			Share(iParaIx->At(iPos.iParaElement),iPos.iParaBasePhraseElement);

   676 		}

   677 	// Alter the length of the original paragraph and the new paragraph.

   678 	TInt currentLength=current.iParaEntry->iLength;

   679 	current.iParaEntry->iLength=iPos.iParaElementOffset;

   680 	((*iParaIx)[iPos.iParaElement+1]).iLength+=currentLength-current.iParaEntry->iLength;  // Alters the length of the copy of aNewPara.

   681 	}

   682 

   683 

   684 void CRichTextIndex::SetForDeleteL(TIndexDeleteInfo& aInfo,TInt aPos,TInt aLength)

   685 //

   686 	{

   687 	__TEST_INVARIANT;  // Do not need to RebalanceIndex(); part of defined behaviour for delete.

   688 

   689 	aInfo.iDeleteLength=aLength;

   690 	//

   691 	// Check for simple cases first

   692 	DocumentChanged();  // clears internal position record.

   693 	ScanToPosition(aPos,EScanToPositionAbsolute,&iLastUsed);

   694 	TCurrentIndexRecords current;

   695 	GetCurrentRecords(current);

   696 	aInfo.iStartPara=iPos.iParaElement;

   697 	aInfo.iEndPara=iPos.iParaElement;  // default

   698 	aInfo.iDeletePos=iPos;  // default

   699 	//

   700 	TInt startParaLength=current.iParaEntry->iLength;

   701 	TInt lengthRemainingInPara=startParaLength-iPos.iParaElementOffset;

   702 	if (aLength<lengthRemainingInPara)

   703 		{// Case is delete-from-paragraph

   704 		aInfo.iDeleteType=TIndexDeleteInfo::EDeleteFromParagraph;

   705 		return;

   706 		}

   707 	//

   708 	ScanToPosition(aPos+aLength,EScanToPositionMatchLeft,&iLastUsed);  // Forces endPara to be next para when just removing a para delimiter.

   709 	aInfo.iEndPara=iPos.iParaElement;

   710 //	if (iPos.iParaElementOffset==0)

   711 //		{// Can use delete-paragraph

   712 //		aInfo.iDeleteType=TIndexDeleteInfo::EDeleteParagraph;

   713 //		return;

   714 //		}

   715 	//

   716 	// Set for the general (leaving) delete.

   717 	GetCurrentRecords(current);

   718 	CParaAttribs* reclaimedEndPara=RequestReclaimShareL(current.iParaAttribs,current.iParaEntry); // does not release share.

   719 	TParaAttribsEntry* origEndParaEntry=current.iParaEntry;

   720 	CParaAttribs* origParaAttribs=current.iParaAttribs;

   721 	TInt endPosPhrase=iPos.iPhraseElement;

   722 	if (reclaimedEndPara)

   723 		origEndParaEntry->iParaAttribs=reclaimedEndPara;

   724 	// Get start para info.

   725 	ScanToPosition(aPos,EScanToPositionAbsolute);

   726 	GetCurrentRecords(current);

   727 	CParaAttribs* reclaimedStartPara=NULL;

   728 	TRAPD(ret,

   729 	reclaimedStartPara=RequestReclaimShareL(current.iParaAttribs,current.iParaEntry));

   730 		if (ret!=KErrNone)

   731 			{

   732 			if (reclaimedEndPara)

   733 				{

   734 				reclaimedEndPara->Release();

   735 				RemoveFromPhraseIx(endPosPhrase);

   736 				origEndParaEntry->iParaAttribs=origParaAttribs;

   737 				}

   738 			User::Leave(ret);

   739 			}

   740 	if (reclaimedEndPara)

   741 		origParaAttribs->Release();  // Release share on the original end para attribs

   742 	if (reclaimedStartPara)

   743 		{// Use the specific start  para

   744 		current.iParaAttribs->Release();

   745 		current.iParaEntry->iParaAttribs=reclaimedStartPara;

   746 		ScanToPosition(aPos,EScanToPositionAbsolute);  // Pick up reclaimed phrase.

   747 		}

   748 	aInfo.iDeletePos=iPos;  // internal position of aPos after any reclaim

   749 	// Note: iDeleteType can surely be made obsolete now? TPB 7/11/2000

   750 	aInfo.iDeleteType=TIndexDeleteInfo::EDeleteFromParagraph;

   751 	

   752 	/*

   753 	 * Pointer to memory allocated to 'reclaimedEndPara' is assigned to 

   754 	 * 'origEndParaEntry->iParaAttribs' on line 706. The memory will be 

   755 	 * released in CRichTextIndex's destructor.

   756 	 */ 

   757 	// coverity[memory_leak]

   758 	}

   759 

   760 

   761 TBool CRichTextIndex::DeleteParagraph(TInt aPos,TInt aLength)

   762 // Remove aCount entire paragraphs from the text.

   763 // Leave-safe

   764 // Returns EFalse indicating that no paragraphs were merged together,

   765 // as a result of the delete action.

   766 // Does NOT preserve any zero-length/insert pending state.

   767 //

   768 	{

   769 	__TEST_INVARIANT;  // Do not need to RebalanceIndex(); part of defined behaviour for delete.

   770 

   771 	CancelInsertCharFormat();

   772 	ScanToPosition(aPos,EScanToPositionAbsolute,&iLastUsed);

   773 

   774 	__ASSERT_DEBUG(iPos.iParaElementOffset==0,Panic(EDeleteParagraphInvalidStartValue));

   775 

   776 	TIndexDeleteInfo info;

   777 	info.iDeleteType=TIndexDeleteInfo::EDeleteParagraph;

   778 	info.iDeletePos=iPos;

   779 	info.iStartPara=iPos.iParaElement;

   780 	//

   781 	TInt documentLength=iText.DocumentLength();

   782 	TInt pos=(aPos+aLength>documentLength

   783 		? documentLength

   784 		: aPos+aLength);

   785 	ScanToPosition(pos,EScanToPositionMatchLeft,&iLastUsed);  // Forces endPara to be next para when just removing a para delimiter.

   786 

   787 	info.iEndPara=iPos.iParaElement;

   788 	info.iDeleteLength=aLength;

   789 

   790 	DeleteNow(info);

   791 	// do not want to call TidyAfterDelete()

   792 

   793 	return EFalse;

   794 	}

   795 

   796 

   797 

   798 void CRichTextIndex::DeleteFromParagraph(TInt aPos,TInt aLength)

   799 // Special case delete for removing content from within a single paragraph only.

   800 // Not to be used for deleting an entire paragraph or paragraphs.

   801 // Returns EFalse indicating that no paragraphs were merged together,

   802 // as a result of the delete action.

   803 //

   804 	{

   805 	__TEST_INVARIANT;  // Do not need to RebalanceIndex(); part of defined behaviour for delete.

   806 

   807 	ScanToPosition(aPos,EScanToPositionAbsolute);

   808 

   809 #ifdef _DEBUG

   810 	{

   811 	TCurrentIndexRecords current;

   812 	GetCurrentRecords(current);

   813 	TInt startParaLength=current.iParaEntry->iLength;

   814 	TInt lengthRemainingInPara=startParaLength-iPos.iParaElementOffset;

   815 

   816 	__ASSERT_ALWAYS(aLength<lengthRemainingInPara,Panic(EDeleteFromParagraphInvalidRange));

   817 	}

   818 #endif

   819 

   820 	TIndexDeleteInfo info;

   821 	info.iDeleteLength=aLength;

   822 	info.iStartPara=iPos.iParaElement;

   823 	info.iEndPara=iPos.iParaElement;

   824 	info.iDeletePos=iPos;

   825 	info.iDeleteType=TIndexDeleteInfo::EDeleteFromParagraph;

   826 

   827 	DoDeleteFromParagraph(info);

   828 

   829 	__TEST_INVARIANT;

   830 	}

   831 

   832 

   833 TBool CRichTextIndex::DoDeleteFromParagraph(const TIndexDeleteInfo& aInfo)

   834 // Delete content from *within* the boundary of a single paragraph only.0

   835 // Returns EFalse indicating that no paragraphs were merged together,

   836 // as a result of the delete action.

   837 //

   838 	{

   839 	iPos=aInfo.iDeletePos;

   840 	TInt length=aInfo.iDeleteLength;

   841 	DeleteParagraphText(length);

   842 	TidyAfterDelete(aInfo);

   843 

   844 	return EFalse;

   845 	}

   846 

   847 

   848 TBool CRichTextIndex::DeleteNow(TIndexDeleteInfo& aInfo)

   849 // Deletes index data corresponding the info argument.

   850 // Returns ETrue is 2 paragraphs are merged as a result of the delete, otherwise returns false.

   851 //

   852 	{

   853 	iPos=aInfo.iDeletePos;

   854 	TCurrentIndexRecords current;

   855 	GetCurrentRecords(current);

   856 	TInt leftToDelete=aInfo.iDeleteLength;

   857 	TInt charsLeftInPara=(current.iParaEntry->iLength)-(iPos.iParaElementOffset);

   858 	TBool doParaMerge=((iPos.iPhraseElement>0 || iPos.iPhraseElementOffset>0) && leftToDelete>=charsLeftInPara);

   859 	// ETrue if the 1st para has content remaining but no paragraph delimiter.

   860 	//

   861 	TBool firstParaRemoved=(FirstPhraseOfParagraph() && iPos.iPhraseElementOffset==0 && aInfo.iDeleteLength>=current.iParaEntry->iLength);

   862 	// ETrue if the 1st para has been *wholly* deleted.

   863 	//

   864 	DeleteParagraphText(leftToDelete);  // Delete range will be in a minimum of 1 paragraph.

   865 	if (aInfo.iStartPara<aInfo.iEndPara)

   866 		{// The delete range crosses paragraph boundaries.

   867 		for (TInt currentPara=aInfo.iStartPara+1;currentPara<=aInfo.iEndPara;currentPara++)

   868 			{

   869 			ScanToPosition(aInfo.iDeletePos.iDocPos,EScanToPositionAbsolute);

   870 			DeleteParagraphText(leftToDelete);

   871 			}

   872 		}

   873 	// Now tidy up

   874 	if (doParaMerge && !firstParaRemoved)

   875 		{// Merge the 2 paras together.

   876 		TParaAttribsEntry* paraEntry=&(*iParaIx)[aInfo.iStartPara];

   877 		TParaAttribsEntry* paraEntryFollowing=&(*iParaIx)[aInfo.iStartPara+1];

   878 		paraEntryFollowing->iLength+=paraEntry->iLength;  // Extend length of remaining para.

   879 		paraEntryFollowing->iParaAttribs->iPhraseCount+=paraEntry->iParaAttribs->iPhraseCount;  // Extend phrase count

   880 		paraEntry->iParaAttribs->Release();

   881 		iParaIx->Delete(aInfo.iStartPara);

   882 		}

   883 	if (aInfo.iDeleteType!=TIndexDeleteInfo::EDeleteParagraph)

   884 		TidyAfterDelete(aInfo);

   885 

   886 	__TEST_INVARIANT;

   887 	return doParaMerge;

   888 	}

   889 

   890 

   891 void CRichTextIndex::TidyAfterDelete(const TIndexDeleteInfo& aInfo)

   892 //

   893 //

   894 	{

   895 	MergePhrases(aInfo.iDeletePos.iDocPos);  // Alters internal position record.

   896 	TCurrentIndexRecords current;

   897 	GetCurrentRecords(current);  // So must get records again.

   898 	if (!current.iParaAttribs->IsShared())

   899 		{// May be able to reclaim a share from this *specific* record

   900 		CParaAttribs* sharedParaAttribs=RequestShare(iPos);

   901 		if (sharedParaAttribs!=NULL && current.iParaAttribs!=sharedParaAttribs)

   902 			{// Use this shared record

   903 			current.iParaAttribs->Release();

   904 			RemoveFromPhraseIx(iPos.iPhraseElement);

   905 			current.iParaEntry->iParaAttribs=sharedParaAttribs;

   906 			}

   907 		}

   908 	}

   909 

   910 

   911 void CRichTextIndex::Normalize(TInt aPos)

   912 //

   913 	{

   914 	ScanToPosition(aPos,EScanToPositionAbsolute);

   915 	NormalizeNow(iPos);

   916 

   917 	__TEST_INVARIANT;

   918 	}

   919 

   920 

   921 void CRichTextIndex::NormalizeNow(const TLogicalPosition& aNormalizePos)

   922 //

   923 	{

   924 	CParaAttribs* currentParaAttribs=(*iParaIx)[aNormalizePos.iParaElement].iParaAttribs;

   925 	if (!currentParaAttribs->IsShared())

   926 		{

   927 		CParaAttribs* sharedParaAttribs=RequestShare(iPos);

   928 		if (sharedParaAttribs!=NULL && currentParaAttribs!=sharedParaAttribs)

   929 			{// We must have been given a share on something already in the shared list.  Dump current stuff.

   930 			currentParaAttribs->Release();

   931 			(*iParaIx)[aNormalizePos.iParaElement].iParaAttribs=sharedParaAttribs;

   932 			RemoveFromPhraseIx(aNormalizePos.iParaBasePhraseElement);

   933 			}

   934 		}

   935 	}

   936 

   937 

   938 CParaAttribs* CRichTextIndex::ReserveCellLC()

   939 // Returns a handle to a newly created CParaAttribs object.  This may be used

   940 // during a call to GetParaAttribsL() as a pre-allocated cell, thus ensuring

   941 // that the call cannot possibly leave.

   942 // ASSUMES: that the internal position record has been set correctly.

   943 //

   944 	{

   945 	CParaAttribs* reservedCell=ReserveCellL();

   946 	CleanupStack::PushL(TCleanupItem(ReleaseOnCleanup,reservedCell));

   947 	return reservedCell;

   948 	}

   949 

   950 

   951 CParaAttribs* CRichTextIndex::ReserveCellL()

   952 // Returns a handle to a newly created CParaAttribs object.  This may be used

   953 // during a call to GetParaAttribsL() as a pre-allocated cell, thus ensuring

   954 // that the call cannot possibly leave.

   955 // ASSUMES: that the internal position record has been set correctly.

   956 //

   957 	{

   958 	TCurrentIndexRecords current;

   959 	GetCurrentRecords(current);

   960 	const CParaAttribs& paraAttribs=*current.iParaAttribs;

   961 	CParaFormatLayer* paraLayer=paraAttribs.iParaFormat;

   962 	CCharFormatLayer* charLayer=(paraAttribs.IsShared())

   963 								? paraAttribs.iCharFormat

   964 								: (*iPhraseIx)[iPos.iPhraseElement].CharFormat();

   965 	CParaAttribs* reservedCell=CParaAttribs::NewL(paraLayer,charLayer);

   966 	return reservedCell;

   967 	}

   968 

   969 

   970 TBool CRichTextIndex::DeleteParagraphText(TInt& aLength)

   971 // Called once for each paragraph that's included in the delete range.

   972 // Assumes the internal position record has already been set correctly.

   973 // The delete range may cover: (1) The entire paragraph - so just destroy the paragraph,

   974 // (2i) At least a portion of a single phrase, and possibly

   975 // (2ii) 0..n whole contiguous phrases, and possibly

   976 // (2iii) a trailing partial phrase.

   977 // Returns ETrue if the full paragraph is deleted, otherwise returns EFalase.

   978 //

   979 	{

   980 	TCurrentIndexRecords current; GetCurrentRecords(current);

   981 	if (FirstPhraseOfParagraph() && iPos.iPhraseElementOffset==0 && aLength>=current.iParaEntry->iLength)

   982 		{// The entire paragraph needs to be deleted.

   983 		aLength-=current.iParaEntry->iLength;

   984 		if (!current.iParaAttribs->IsShared())

   985 			RemoveFromPhraseIx(iPos.iParaBasePhraseElement,current.iParaAttribs->iPhraseCount);

   986 		current.iParaAttribs->Release();

   987 		iParaIx->Delete(iPos.iParaElement);

   988 		return ETrue;

   989 		}

   990 	TInt deleteFromPhrase=CurrentPhraseLength()-iPos.iPhraseElementOffset;

   991 	TInt maxPhrase=current.iParaAttribs->PhraseCount();

   992 	TInt currentPhrase=(iPos.iPhraseElement-iPos.iParaBasePhraseElement);

   993 	while (currentPhrase<maxPhrase)

   994 		{

   995 		TInt deletable=Min(deleteFromPhrase,aLength);

   996 		current.iParaEntry->iLength-=deletable;  // Adjust the paragraph length.

   997 		if (current.iPhrase && deletable>=CurrentPhraseLength())

   998 			{// Remove the now empty phrase from the phrase index.

   999 			RemoveFromPhraseIx(iPos.iPhraseElement);

  1000 			current.iParaAttribs->iPhraseCount--;

  1001 			}

  1002 		else if (current.iPhrase)

  1003 			{// Adjust phrase length and move onto the next phrase.

  1004 			current.iPhrase->AdjustLength(-deletable);

  1005 			iPos.iPhraseElement++;

  1006 			iPos.iPhraseElementOffset=0;

  1007 			}

  1008 		currentPhrase++;

  1009 		aLength-=deletable;

  1010 		if(aLength==0)

  1011 			break;  // Nothing left to delete in this paragraph.

  1012 		// Get the data for the next phrase.

  1013 		GetCurrentRecords(current);

  1014 		deleteFromPhrase=CurrentPhraseLength();

  1015 		}

  1016 	return EFalse;

  1017 	}

  1018 

  1019 TBool CRichTextIndex::InsertCharFormatIsActive()

  1020 	{

  1021 	return iPendingNewPhrasePos != EInsertCharFormatReset;

  1022 	}

  1023 

  1024 /** Sets an *InsertPending* state, where format has been inserted into the

  1025 text, but no content has yet been inserted. This *state* is cancelled by cursor

  1026 movement etc. Split the current phrase at aPos (if necessary) and insert a zero

  1027 length phrase, ready to accept the pending content of the specified format.

  1028 */

  1029 void CRichTextIndex::SetInsertCharFormatL(const TCharFormatX& aFormat,const TCharFormatXMask& aMask,TInt aPos)

  1030 	{

  1031 	__ASSERT_ALWAYS(!InsertCharFormatIsActive() || aPos==iPendingNewPhrasePos,

  1032 					Panic(ESetInsertCharFormatIntegrityErr));

  1033 	if (InsertCharFormatIsActive())

  1034 		UpdateInsertCharFormatL(aFormat, aMask);

  1035 	else

  1036 		NewInsertCharFormatL(aFormat, aMask, aPos);

  1037 	}

  1038 

  1039 void CRichTextIndex::NewInsertCharFormatL(const TCharFormatX& aFormat,

  1040 	const TCharFormatXMask& aMask, TInt aPos)

  1041 	{

  1042 	__ASSERT_ALWAYS(!InsertCharFormatIsActive(),

  1043 		Panic(ESetInsertCharFormatIntegrityErr));

  1044 	ScanToPosition(aPos,EScanToPositionMatchLeft);

  1045 	TCurrentIndexRecords current;

  1046 	GetCurrentRecords(current);

  1047 	CCharFormatLayer* basedOn;

  1048 	TCharFormatX applyFormat=aFormat;

  1049 	TCharFormatXMask applyMask=aMask;

  1050 	GetPhraseFormat(current,applyFormat,applyMask,basedOn);  // Inherit phrase attributes to the left, over what is present.

  1051 	TBool origParaAttribsShared=current.iParaAttribs->IsShared();

  1052 	if (origParaAttribsShared)

  1053 		{// Current paraAttribs is shared.

  1054 		iRollbackParaAttribsHandle=current.iParaAttribs;

  1055 		current.iParaEntry->iParaAttribs=RequestReclaimShareL(current.iParaAttribs,current.iParaEntry);  // Does not release share.

  1056 		ScanToPosition(aPos,EScanToPositionMatchLeft);  // Pick up reclaimed phrase.

  1057 		}  // Now current.iParaAttribs has specific character formatting - guaranteed.

  1058 	GetCurrentRecords(current);

  1059 	TRAPD(ret, DoNewInsertCharFormatL(applyFormat, applyMask,

  1060 		basedOn, current.iParaAttribs));

  1061 	if (ret!=KErrNone)

  1062 		{// Rollback as if this function call never happened.

  1063 		if (origParaAttribsShared)

  1064 			{// Revert back to sharing the original.

  1065 			current.iParaAttribs->Release();

  1066 			RemoveFromPhraseIx(iPos.iPhraseElement);

  1067 			current.iParaEntry->iParaAttribs=iRollbackParaAttribsHandle;

  1068 			}

  1069 		else

  1070 			{// Restore the original phrase index.

  1071 			if (PhraseSplit())

  1072 				MergePhrases(aPos);

  1073 			}

  1074 		User::LeaveNoMemory();

  1075 		}

  1076 	iPendingNewPhrasePos=aPos;

  1077 	}

  1078 

  1079 void CRichTextIndex::UpdateInsertCharFormatL(const TCharFormatX& aFormat,

  1080 	const TCharFormatXMask& aMask)

  1081 	{

  1082 	CCharFormatLayer* currentLayer = GetCurrentInsertCharFormat();

  1083 	CCharFormatLayer* newLayer = CCharFormatLayer::NewCopyBaseL(currentLayer);

  1084 	CleanupStack::PushL(newLayer);

  1085 	newLayer->SetL(aFormat, aMask);

  1086 	currentLayer->Swap(*newLayer);

  1087 	CleanupStack::PopAndDestroy(newLayer);

  1088 	}

  1089 

  1090 CCharFormatLayer* CRichTextIndex::GetCurrentInsertCharFormat()

  1091 	{

  1092 	__ASSERT_DEBUG(InsertCharFormatIsActive(),

  1093 		Panic(ESetInsertCharFormatIntegrityErr));

  1094 	ScanToPosition(iPendingNewPhrasePos,EScanToPositionMatchLeft);

  1095 	TCurrentIndexRecords current;

  1096 	GetCurrentRecords(current);

  1097 	__ASSERT_DEBUG((*iPhraseIx)[iPos.iPhraseElement].Length() == 0,

  1098 		Panic(ESetInsertCharFormatIntegrityErr));

  1099 	return (*iPhraseIx)[iPos.iPhraseElement].CharFormat();

  1100 	}

  1101 

  1102 void CRichTextIndex::DoNewInsertCharFormatL(const TCharFormatX& aFormat,const TCharFormatXMask& aMask,

  1103 											CCharFormatLayer* aBasedOn,CParaAttribs* aParaAttribs)

  1104 	{

  1105 	SplitPhraseL(iPos.iPhraseElement,iPos.iPhraseElementOffset,aParaAttribs);

  1106 	CCharFormatLayer* layer=CCharFormatLayer::NewL();

  1107 	layer->SetBase(aBasedOn);  // must be done before the SetL().

  1108 	CleanupStack::PushL(layer);

  1109 	layer->SetL(aFormat,aMask);

  1110 	RPhraseAttribsEntry pendingNewPhrase(layer);

  1111 	TInt pendingNewPhraseElement=(FirstPhraseOfParagraph() && iPos.iPhraseElementOffset==0)

  1112 		?iPos.iParaBasePhraseElement:iPos.iPhraseElement+1;

  1113 	iPhraseIx->InsertL(pendingNewPhraseElement,pendingNewPhrase);

  1114 	CleanupStack::Pop();

  1115 	aParaAttribs->iPhraseCount++;

  1116 	}

  1117 

  1118 

  1119 void CRichTextIndex::RebalanceIndex()

  1120 // Returns the index to a good state, by releasing the extra share taken on the paraAttribs

  1121 //

  1122 	{

  1123 	if (iRollbackParaAttribsHandle)

  1124 		{

  1125 		// ASSERT: The specified para attribs is indeed in the share list.

  1126 		__ASSERT_ALWAYS(iRollbackParaAttribsHandle->IsShared(),Panic(EParaAttribsNotInSharedList));

  1127 		iRollbackParaAttribsHandle->Release();

  1128 		iRollbackParaAttribsHandle=NULL;

  1129 		}

  1130 	}

  1131 

  1132 /** Cancels the transitory state where a specified character format is applied

  1133 on top of any inherited formatting. eg, when bold is on. Cancel when: (1) the

  1134 text position is altered. (2) the first character (or picture) has been