/*

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

 * All rights reserved.

 * This component and the accompanying materials are made available

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

 * which accompanies this distribution, and is available

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

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description: 

 *

 */

 #include "TXTETEXT.H"

 #include "TXTSTD.H"

 #include "OstTraceDefinitions.h"

 #ifdef OST_TRACE_COMPILER_IN_USE

 #include "TXTSCANTraces.h"

 #endif

 EXPORT_C TInt CPlainText::CharPosOfParagraph(TInt& aLength,TInt aParaOffset)const

 /** Finds the length and the start position of a paragraph identified by its 

 paragraph number the first paragraph is numbered zero.

 Notes:

 if aParaOffset is invalid, (equal to or greater than the total number of 

 paragraphs), the function's return value is EScanEndOfData

 @param aLength On return contains the length of the specified paragraph. 

 @param aParaOffset The paragraph number. The first paragraph is numbered zero. 

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

 	{

 	__TEST_INVARIANT;

 	TInt startPos=aLength=0;

 	TUint scanMask=(EScanToUnitStart);

 	aLength=ScanParas(startPos,scanMask);

 	for (TInt offset=1;offset<=aParaOffset;offset++)

 		{

 		if (startPos<=EScanEndOfData)

 			return EScanEndOfData;

 		aLength=ScanParas(startPos,scanMask);

 		}

 	if (startPos==EScanEndOfData)

 		startPos=iByteStore->Size()/sizeof(TText);

 	return startPos-aLength;

 	}

 EXPORT_C TInt CPlainText::ParagraphNumberForPos(TInt& aPos)const

 /** Gets the number of the paragraph which contains a document position. 

 Paragraph numbering begins at zero.

 @param aPos A document position. Must be valid or a panic occurs. On return, 

 contains the document position of the first character in the paragraph in 

 which it is located. 

 @return The number of the paragraph containing the specified document position.

 The first paragraph is numbered zero. */

 	{

 	__TEST_INVARIANT;

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

 	    {

 	    OstTrace0( TRACE_FATAL, CPLAINTEXT_PARAGRAPHNUMBERFORPOS, "ECharPosBeyondDocument" );

 	    }

 	__ASSERT_ALWAYS(aPos>=0 && aPos<=DocumentLength(),Panic(ECharPosBeyondDocument));

 	TUint scanMask=(EScanBackwards|EScanStayIfBoundary|EScanToUnitStart);

 	ScanParas(aPos,scanMask);

 	// aPos now holds the 1st char of the paragraph.

 	TInt paraOffset=0,currentPos=0;

 	scanMask=EScanToUnitStart;

 	while (currentPos<aPos)

 		{// Move forwards, counting paragraphs until we get to the current position.

 		paraOffset++;

 		ScanParas(currentPos,scanMask);

 		}

 	return paraOffset;

 	}

 EXPORT_C void CPlainText::GetWordInfo(TInt aCurrentPos,TInt& aStartPos,TInt& aLength,

 									  TBool aPictureIsDelimiter,TBool aPunctuationIsDelimiter)const

 /** Gets the start position and length of the word that contains the document 

 position specified.

 @param aCurrentPos A document position. Must be valid or a panic occurs. 

 @param aStartPos On return, the document position of the first character in 

 the word containing the position aCurrentPos.

 @param aLength On return, the length of the word containing document position 

 aCurrentPos.

 @param aPictureIsDelimiter ETrue if picture characters should be treated as 

 word delimiters, false if not. For example, when navigating text, this might 

 be EFalse, but when spell checking, it might be ETrue. 

 @param aPunctuationIsDelimiter ETrue if punctuation characters should be treated 

 as word delimiters, EFalse if not. */

 	{

 	__TEST_INVARIANT;

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

 	    {

 	    OstTrace0( TRACE_FATAL, CPLAINTEXT_GETWORDINFO, "ECharPosBeyondDocument" );

 	    }

 	__ASSERT_ALWAYS(aCurrentPos>=0 && aCurrentPos<=DocumentLength(),Panic(ECharPosBeyondDocument));

 	aStartPos=aLength=aCurrentPos;

 	// First find the start of the word.

 	TUint scanMask=(EScanBackwards|

 					EScanStayIfBoundary|

 					EScanToUnitStart);

 	if (aPictureIsDelimiter)

 		scanMask|=EScanPictureIsDelimiter;

 	if (aPunctuationIsDelimiter)

 		scanMask|=EScanPunctuationIsDelimiter;

 	ScanWords(aStartPos,scanMask);

 	// Next find the end of the word.

 	scanMask=(EScanStayIfBoundary|EScanToUnitEnd);

 	if (aPictureIsDelimiter)

 		scanMask|=EScanPictureIsDelimiter;

 	if (aPunctuationIsDelimiter)

 		scanMask|=EScanPunctuationIsDelimiter;

 	ScanWords(aLength,scanMask);

 	aLength-=aStartPos;

 	if (aLength+aStartPos>(DocumentLength()+1))

 	    {

 	    OstTrace0( TRACE_DUMP, DUP2_CPLAINTEXT_GETWORDINFO, "ECharPosBeyondDocument" );

 	    }

 	__ASSERT_DEBUG(aLength+aStartPos<=(DocumentLength()+1),Panic(ECharPosBeyondDocument));

 	__TEST_INVARIANT;

 	}

 EXPORT_C TInt CPlainText::ToParagraphStart(TInt& aPos) const

 /** Gets the document position of the start of the paragraph containing the 

 specified document position.

 @param aPos A document position. Must be valid or a panic occurs. On return, 

 contains the document position of the first character in the paragraph in 

 which it is located.

 @return The number of characters skipped in scanning to the start of the 

 paragraph. */

 	{

 	__TEST_INVARIANT;

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

 	    {

 	    OstTrace0( TRACE_FATAL, CPLAINTEXT_TOPARAGRAPHSTART, "ECharPosBeyondDocument" );

 	    }

 	__ASSERT_ALWAYS(aPos>=0 && aPos<=DocumentLength(),Panic(ECharPosBeyondDocument));

 	int skipped = 0;

 	while (aPos > 0)

 		{

 		TPtrC8 p = iByteStore->BackPtr(aPos * sizeof(TText));

 		const TText* start = (TText*)p.Ptr();

 		const TText* end = start + p.Length() / sizeof(TText);

 		while (end > start)

 			{

 			end--;

 			if (*end == EParagraphDelimiter)

 				return skipped;

 			aPos--;

 			skipped++;

 			}

 		}

 	return skipped;

 	}

 EXPORT_C TInt CPlainText::WordCount()const

 /** Gets a count of the number of words in the text object.

 @return The number of words in the text object. */

 	{return CountUnits(EUnitIsWord);}

 EXPORT_C TInt CPlainText::ParagraphCount()const

 /** Gets a count of the number of paragraphs in the text object.

 Note: the paragraph delimiter which terminates every text object means this 

 function always returns a count of at least one.

 @return The number of paragraphs contained in the text object. */

 	{//return CountUnits(EUnitIsParagraph);}

 	TInt pos=0,unitCount=0;

 	TUint scanMask=(EScanToUnitStart);

 	while (pos!=EScanEndOfData)

 		{

 		unitCount++;

 		ScanParas(pos,scanMask);

 		}

 	return unitCount;

 	}

 TInt CPlainText::CountUnits(TUnitOfText aContext)const

 // Returns the number of units in the document, where

 // units are defined by the parameter aContext.

 //

 	{

 	SScanData scanData;

 	TInt pos=0,unitCount=0;

 	TUint scanMask=(EScanToUnitStart|EScanJoinDelimiters|EScanStayIfBoundary);

 	InitScanControl(pos,scanMask,aContext,scanData);

 	ScanUnit(pos,aContext,scanData);

 	// The above code skips over leading white space

 	scanData.scanMask &=~ EScanStayIfBoundary;

 	while(pos!=EScanEndOfData)

 		{

 		unitCount++;

 		ScanUnit(pos,aContext,scanData);

 		}//	Count complete, so return pos to the beginning of the data

 	pos=0;

 	return unitCount;

 	}

 EXPORT_C TInt CPlainText::ScanWords(TInt& aPos,TUint& aScanMask)const

 /** Scans from a document position to the beginning or end of a word. The 

 destination is determined by a scan mask. The scan can either be forwards 

 (the default) or backwards, and the destination may be the first or last 

 character in the word containing the position, or the first character in 

 the next word.

 Note: If an attempt is made to scan beyond the end of text delimiter, on return, 

 aPos is set to EScanEndOfData  and the function's return value indicates 

 the number of characters skipped in passing the end of text delimiter.

 @param aPos The document position from which to scan. Must be valid, or a 

 panic occurs. On return, contains the new document position. 

 @param aScanMask The scan mask. See the enumeration whose values begin with 

 CPlainText::EScanBackwards. 

 @return The number of characters skipped to reach the new document position. */

 	{

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

 	    {

 	    OstTrace0( TRACE_FATAL, CPLAINTEXT_SCANWORDS, "ECharPosBeyondDocument" );

 	    }

 	__ASSERT_ALWAYS(aPos>=0 && aPos<=DocumentLength(),Panic(ECharPosBeyondDocument));

 	SScanData scanData;

 	InitScanControl(aPos,aScanMask,EUnitIsWord,scanData);

 	return ScanUnit(aPos,EUnitIsWord,scanData);

 	}

 EXPORT_C TInt CPlainText::ScanParas(TInt& aPos,TUint& aScanMask)const

 /** Scans from a document position to the beginning or end of a paragraph. The 

 destination is determined by a scan mask. The scan can either be forwards 

 (the default) or backwards, and the destination may be the first or last 

 character in the paragraph containing the position, or the first character in 

 the next paragraph. 

 Note: if an attempt is made to scan beyond the end of text delimiter, on return, 

 aPos is set to EScanEndOfData ) and the function's return value indicates 

 the number of characters skipped in passing the end of text delimiter.

 @param aPos The document position to scan from. Must be valid or a panic occurs. 

 On return, contains the new document position. 

 @param aScanMask The scan mask. See the enumeration whose values begin with 

 CPlainText::EScanBackwards. 

 @return The number of characters skipped to reach the new document position. */

 	{

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

 	    {

 	    OstTrace0( TRACE_FATAL, CPLAINTEXT_SCANPARAS, "ECharPosBeyondDocument" );

 	    }

 	__ASSERT_ALWAYS(aPos>=0 && aPos<=DocumentLength(),Panic(ECharPosBeyondDocument));

 	SScanData scanData;

 	InitScanControl(aPos,aScanMask,EUnitIsParagraph,scanData);

 	return ScanUnit(aPos,EUnitIsParagraph,scanData);

 	}

 void CPlainText::InitScanControl(TInt& aPos,TUint& aScanMask,TUnitOfText aContext,SScanData& aScanData)const

 // Initialises the control segment of the bitmask

 // used to determine when scan has completed.

 // Calls the initialisation of aScanData.

 //

 	{

 	aScanData.pos=aPos;

 	aScanData.scanMask=0;

 	aScanData.scanMask|=aScanMask;

 	if (aScanData.scanMask & EScanStayIfBoundary)

 		{//Scan one unit the other way first.

 			aScanData.scanMask ^= EScanBackwards;  // Alter scan direction.

 			InitScanData(aScanData.pos,aScanData);				

 			TestForDelimiter(aContext,aScanData);

 			aScanData.scanMask ^= EScanBackwards;  // Restore original scan direction.

 		}

 	InitScanData(aScanData.pos,aScanData);

 	if(!aPos && (aScanData.scanMask&(EScanStayIfBoundary|EScanBackwards))==EScanStayIfBoundary)

 		{//At the start of the buffer and scanning forwards and ScanStayIfBoundary set.

 		aScanData.scanMask &=~aScanData.EInsideUnit;

 		}

 	else 

 		{

 		TestForDelimiter(aContext,aScanData);

 		if (aScanData.scanMask & aScanData.EIsDelimiter)

 			aScanData.scanMask &=~ aScanData.EInsideUnit;

 		else

  			aScanData.scanMask |= aScanData.EInsideUnit;

 		}

 	if (aScanData.scanMask & EScanBackwards)

 		{//Set stop flags relative to scan direction

 		if (aScanData.scanMask &  EScanToUnitStart)

 			aScanData.scanMask |= aScanData.EStopEnd;

 		if (aScanData.scanMask &  EScanToUnitEnd)

 			aScanData.scanMask |= aScanData.EStopBegin;

 		}

 	else

 		{//Set stop flags relative to scan direction

 		if (aScanData.scanMask &  EScanToUnitStart)

 			aScanData.scanMask |= aScanData.EStopBegin;

 		if (aScanData.scanMask &  EScanToUnitEnd)

 			aScanData.scanMask |= aScanData.EStopEnd;

 		}

 	}

 void CPlainText::InitScanData(TInt aPos,SScanData& aScanData)const

 // Initialises the necessary elements of the scan structure, for ScanXxx 

 // methods.  These are used to track scan progress.

 //

 	{

 	aScanData.pos=aPos;

 	aScanData.oldPos=aPos;

 	aScanData.currentSegLen=0;

 	if (aScanData.scanMask & EScanBackwards)

 		{//Scanning backwards.

 		aScanData.delta=-1;

 		aScanData.totalBufLen=aPos;

 		}

 	else

 		{//Scanning forwards.

 		aScanData.delta=+1;

 		aScanData.totalBufLen=((iByteStore->Size()/sizeof(TText))-aScanData.pos);

 		}

 	}	

 TInt CPlainText::ScanUnit(TInt& aPos,TUnitOfText aContext,SScanData& aScanData)const

 // Scan from position aPos, by one unit.

 // Update aPos to the current position, and return the number

 // of characters skipped or EScanEndOfData if at the end of the buffer.

 //

 	{

 	while (TestForDelimiter(aContext,aScanData))

 		{//More data has been read

 		if (aScanData.scanMask & aScanData.EInsideUnit)

 			{

 			if (aScanData.scanMask & aScanData.EIsDelimiter)

 				{

 				aScanData.scanMask &=~aScanData.EInsideUnit;

 				if (aScanData.scanMask & aScanData.EStopEnd)

 					break;

 				}

 			 }

 		else

 			{

 			if (aScanData.scanMask & aScanData.EIsDelimiter)

 				{

 				if (!(aScanData.scanMask & EScanJoinDelimiters))

 					break;

 				}

 	   		else

 				{

 				aScanData.scanMask |= aScanData.EInsideUnit;

 				if (aScanData.scanMask & aScanData.EStopBegin)

 					break;

 				}

 			}

 		}

 	TInt charsSkipped=(aScanData.scanMask & EScanBackwards)? aPos-aScanData.oldPos : 

 										aScanData.oldPos-aPos;

 	aPos=(aScanData.oldPos<(TInt)(iByteStore->Size()/sizeof(TText)))? aScanData.oldPos : EScanEndOfData;

 	return charsSkipped;

 	}

 TBool CPlainText::TestForDelimiter(TUnitOfText aContext,SScanData& aScanData) const

 /** Return ETrue if a character was read successfully.

 Set EIsDelimiter flag if the character read

 is a delimiter of the appropriate type.*/	

     {

 	aScanData.scanMask |= aScanData.EIsDelimiter;

 	aScanData.oldPos = aScanData.pos;

 	TChar c;

 	if (!GetChar(aScanData,c))

 		return FALSE;

 	TBool found = FALSE;

 	if (aContext == EUnitIsParagraph)

 		found = c == EParagraphDelimiter;

 	else if (aContext == EUnitIsWord)

 		{

 		if (c == EParagraphDelimiter ||

 			c == ELineBreak ||

 			c == EPageBreak ||

 			c == ESpace ||

 			c == ETabCharacter)

 			found = TRUE;

 		if (!found && (aScanData.scanMask & EScanPictureIsDelimiter))

 			{

 			if (c == EPictureCharacter)

 				found = TRUE;

 			}

 		if (!found)

 			{

 			TChar::TCategory cat = c.GetCategory();

 			if (cat == TChar::EZsCategory) // it's a space

 				found = TRUE;

 			if (!found &&

 				(aScanData.scanMask & EScanPunctuationIsDelimiter) &&

 				(cat & TChar::EPunctuationGroup))

 				{

 				if (c != EHyphenMinus &&

 					c != EApostrophe &&

 					c != EPotentialHyphen &&

 					c != EHyphen && 

 					c != ERightSingleQuote)

 					found = TRUE;

 				}

 			}

 		}

 	if (found)

 		aScanData.scanMask |= aScanData.EIsDelimiter;

 	else

 		aScanData.scanMask &= ~aScanData.EIsDelimiter;

 	return TRUE;

 	}

 TBool CPlainText::GetChar(SScanData& aScanData,TChar& aChar)const

 // If there is one, write the next character to aChar, and return ETrue,

 // otherwise return EFalse.

 //

 	{

 	TPtrC view(_S("a"));  // Dummy value cos no default constructor.

 	if (!aScanData.currentSegLen)	

 		{//First time in, or new segment.

 		if (!aScanData.totalBufLen)

 			{//No data left to read.

 			return EFalse;	

 			}

 		if (aScanData.delta < 0)

 			{//Scanning backwards

 			TPtrC8 tempView=iByteStore->BackPtr(aScanData.pos*sizeof(TText));

 			view.Set((TText*)tempView.Ptr(),tempView.Length()/sizeof(TText));

 			}

 		else

 			{//Scanning forwards

 			TPtrC8 tempView=iByteStore->Ptr(aScanData.pos*sizeof(TText));

 			view.Set((TText*)tempView.Ptr(),tempView.Length()/sizeof(TText));

 			}//Ptr now returns a TDes.

 		aScanData.currentSegLen=(TInt)Min(aScanData.totalBufLen,(TInt)view.Length());

 		aScanData.totalBufLen-=aScanData.currentSegLen;

 		aScanData.buf=(TText*)view.Ptr();

 		if (aScanData.delta < 0)

 			aScanData.buf+=aScanData.currentSegLen-1;

 		}

 	aChar=*(aScanData.buf);  // aChar takes the character just read.

 	aScanData.buf+=aScanData.delta;  // pText increments correctly for both ASCII and Unicode

 	aScanData.pos+=aScanData.delta;

 	aScanData.currentSegLen-=1;  // len holds the number of chars left, for ASCII and Unicode

 	return ETrue;

 	}