/*

* Copyright (c) 2007 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:  Implementation of class CFsTextParser

*

*/

//<cmail> removed __FS_ALFRED_SUPPORT flag

//#include <fsconfig.h>

//</cmail> removed __FS_ALFRED_SUPPORT flag

// <cmail> SF

#include "emailtrace.h"

#include <alf/alftextstylemanager.h>

// </cmail>

#include <eikenv.h>

// <cmail>

#include <AknUtils.h>

// </cmail>

#include <fldinfo.h>

#include "fstextparser.h"

#include "fsrichtexttext.h"

#include "fsrichtextpicture.h"

#include "fsrichtextsmiley.h"

#include "fsrichtextnewline.h"

#include "fsrichtext.h"

#include "fsrichtextfields.h"

#include "fssmileyparser.h"

#include "fstextureloader.h"

#include "fstexture.h"

#include "fstextstylemanager.h"

#include "fbs.h"

CFsTextParser::CFsTextParser(

        CFsRichText& aText,

        CAlfEnv& aEnv,

        CFsTextureLoader* aTextureLoader):

    iText(aText),

    iTextureLoader(aTextureLoader),

    iEnv(aEnv),

    iTextStyleManager(NULL),

    iIsWordTooLong(EFalse),

    iIsSetSizeOfSmiley(EFalse),

    iGetCharsUsed(EFalse),

    iGetCharsUsedOfNextBlock(EFalse),

    iNewLineArrayIndex(0),

    iLastNewLinePositionIndex(0)

    {

    FUNC_LOG;

    }

CFsTextParser* CFsTextParser::NewL(

        CFsRichText& aText,

        CAlfEnv& aEnv,

        CFsTextureLoader* aTextureLoader)

    {

    FUNC_LOG;

    CFsTextParser * self = new(ELeave) CFsTextParser(

            aText,

            aEnv,

            aTextureLoader );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CFsTextParser::~CFsTextParser()

    {

    FUNC_LOG;

    iExpandArray.Close();

    iHotSpotArray.Close();

    iFieldLocation.Close();

    iTextureIndex.Close();

    iNewLineArray.Close();

    iLineDirection.Close();

    delete iSmileyParser;

    }

void CFsTextParser::SetSizeOfSmile(TSize aSizeOfSmiley)

    {

    FUNC_LOG;

    iIsSetSizeOfSmiley = ETrue;

    iSizeOfSmiley = aSizeOfSmiley;

    }

void CFsTextParser::ConstructL()

    {

    FUNC_LOG;

    iEikon = CEikonEnv::Static();

    }

TBool CFsTextParser::SetParsingPosition( TInt aPosition )

    {

    FUNC_LOG;

    TBool retVal = ETrue;

    if( aPosition < 0 || aPosition >= iText.DocumentLength())

        {

        retVal = EFalse;

        }

    else

        {

        iPosition = aPosition;

        }

    return retVal;

    }

void CFsTextParser::MoveBack()

    {

    FUNC_LOG;

    iPosition = iLastPosition;

    }

TInt CFsTextParser::IsWordPartOfExpandArea(

        TInt aStartPosition,

        TInt aEndPosition )

    {

    FUNC_LOG;

    TInt retVal = -1;

    for(TInt i = 0 ; i < iExpandArray.Count() ; ++i)

        {

        if(iExpandArray[i].iStartIndex >= aStartPosition &&

            iExpandArray[i].iStartIndex < aEndPosition)

            {

            if(-1 == retVal)

                {

                retVal = i;

                }

            else

                {

                if ( iExpandArray[i].iStartIndex

                        < iExpandArray[retVal].iStartIndex )

                    {

                    retVal = i;

                    }

                }

            }

        else if ( aStartPosition >= iExpandArray[i].iStartIndex

                && aStartPosition

                  < iExpandArray[i].iStartIndex + iExpandArray[i].iLength )

            {

            if(-1 == retVal)

                {

                retVal = i;

                }

            else

                {

                if ( iExpandArray[i].iStartIndex

                        < iExpandArray[retVal].iStartIndex )

                    {

                    retVal = i;

                    }

                }

            }

        }

    return retVal;

    }

void CFsTextParser::CutWord(TInt aBeginOfWord, TInt aNewLengthOfWord)

    {

    FUNC_LOG;

    iIsWordTooLong = ETrue;

    iPosition = aBeginOfWord;

    iNewLengthOfWord = aNewLengthOfWord;

    }

// ---------------------------------------------------------------------------

// GetTextL

// ---------------------------------------------------------------------------

HBufC* CFsTextParser::GetTextL(TInt aStart, TInt aEnd) const

    {

    FUNC_LOG;

    HBufC* retVal = HBufC::NewL( aEnd - aStart + 1 );

//    TBuf<200> someText01;

    if(aStart < 0 || aEnd > iText.DocumentLength() || aEnd < aStart)

        {

        User::Leave(KErrArgument);

        }

//    someText01.Zero();

    TPtr ptr( retVal->Des() );

    ptr.Append( iText.Read(aStart, aEnd - aStart + 1) );

    while ( ptr.Length() < aEnd - aStart + 1 )

        {

        ptr.Append( iText.Read( aStart + ptr.Length(), aEnd - aStart + 1 - ptr.Length() ) );

        }

//    TPtrC retVal;

//    retVal.Set( someText01.Ptr(), someText01.Length() );

    return retVal;

    }

// ---------------------------------------------------------------------------

// GetTextureL

// ---------------------------------------------------------------------------

CFsTexture& CFsTextParser::GetTextureL(TInt aPos)

    {

    FUNC_LOG;

    if(aPos > iText.DocumentLength())

        {

        User::Leave(KErrArgument);

        }

    const CTextField* field = iText.TextField(aPos);

    CFsTexture* retVal = NULL;

    TInt textureId;

    if(!IsTexturePosition(aPos, textureId))

    	{

		if(KFsRichTextPictureFieldUid == field->Type())

			{

			TPictureHeader header = iText.PictureHeader(aPos);

			CMyPicture* picture =

				static_cast<CMyPicture*>(header.iPicture.AsPtr() );

			CFbsBitmap* bitmap = picture->GetBitmap();

			CFbsBitmap* bitmapMask = picture->GetBitmapMask();

			CFsTexture& texture = (iTextureLoader->AppendBitmapL(bitmap, bitmapMask));

			TTextureIndex newTextureIndex;

			newTextureIndex.iPositionInText = aPos;

			newTextureIndex.iTextureId = texture.Id();

			iTextureIndex.Append(newTextureIndex);

			retVal = &texture;

			}

		else if(KFsRichTextSmileyFieldUid == field->Type())

			{

			TInt smileyIndex = ((CSmileyField*)(field))->GetSmileyIndex();

			TFileName fileName = iSmileyParser->GetSmileyFileName(smileyIndex);

			CFsTexture& texture = iTextureLoader->LoadTextureL( fileName );

			TTextureIndex newTextureIndex;

			newTextureIndex.iPositionInText = aPos;

			newTextureIndex.iTextureId = texture.Id();

			iTextureIndex.Append(newTextureIndex);

			retVal = &texture;

			}

		else

			{

			User::Leave(KErrArgument);

			}

    	}

    else

    	{

    	CFsTexture* texture = iTextureLoader->SearchById(textureId);

    	retVal = texture;

    	}

    return *retVal;

    }

TBool CFsTextParser::IsFieldInrange(TInt aStartPosition, TInt aRange)

    {

    FUNC_LOG;

    TInt siezOfArray = iFieldLocation.Count();

    TBool retVal = EFalse;

    TInt endPosition = aStartPosition + aRange;

    TInt pos;

    for(TInt i = 0 ; i < siezOfArray ; i++)

        {

        pos = iFieldLocation[i];

        if(aStartPosition <= pos && pos <= endPosition)

            {

            retVal = ETrue;

            i = siezOfArray;

            }

        }

    return retVal;

    }

void CFsTextParser::FindBlokOfText()

	{

	if(!iGetCharsUsed)

		{

		iText.GetChars(iGNOSomeText, iGNOCharFormat, iPosition);

		iLastGetCharsPos = iPosition;

		iLastGetCharsLength = iGNOSomeText.Length();

		iGetCharsUsed = ETrue;

		}

	else

		{

		if(iPosition >= iLastGetCharsPos && iPosition < (iLastGetCharsPos + iLastGetCharsLength))

			{

			iGNOSomeText.Set(iText.Read(

									iPosition,

									iLastGetCharsLength - (iPosition - iLastGetCharsPos)));

			iLastGetCharsPos = iPosition;

			iLastGetCharsLength = iGNOSomeText.Length();

			}

		else

			{

			if(iPosition == iLastGetCharsPosOfNextBlock)

				{

				iGNOSomeText.Set(iText.Read(iPosition,

							iLastGetCharsLengthOfNextBlock));

				iLastGetCharsPos = iPosition;

				iLastGetCharsLength = iGNOSomeText.Length();

				iGNOCharFormat = iGNOCharFormatOfNextBlock;

				}

			else

				{

				iText.GetChars(iGNOSomeText, iGNOCharFormat, iPosition);

				iLastGetCharsPos = iPosition;

				iLastGetCharsLength = iGNOSomeText.Length();

				}

			}

		}

	}

void CFsTextParser::FindNextBlokOfText()

	{	

	if(!iGetCharsUsedOfNextBlock)

		{

		iText.GetChars(iGNOSomeTextOfNextBlock, iGNOCharFormatOfNextBlock, iGNONextPosition );		

		iLastGetCharsPosOfNextBlock = iGNONextPosition;

		iLastGetCharsLengthOfNextBlock = iGNOSomeTextOfNextBlock.Length();

		iGetCharsUsedOfNextBlock = ETrue;

		}

	else

		{

		if(iLastGetCharsPosOfNextBlock == iGNONextPosition)

			{

			iGNOSomeTextOfNextBlock.Set(iText.Read(iGNONextPosition,

			iLastGetCharsLengthOfNextBlock));

			}

		else

			{

			iText.GetChars(iGNOSomeTextOfNextBlock, iGNOCharFormatOfNextBlock, iGNONextPosition );

			iLastGetCharsPosOfNextBlock = iGNONextPosition;

			iLastGetCharsLengthOfNextBlock = iGNOSomeTextOfNextBlock.Length();

			}

		}

	}

TInt CFsTextParser::IsNewLinePresent(TInt aPosition, TInt aLength)

	{	

		TInt retVal = -1;

		TInt index = 0;

		TInt newLineArrayCount = iNewLineArray.Count();

		if(iNewLineArray[iNewLineArrayIndex] < aPosition &&

				iNewLineArray[iNewLineArrayIndex] < (aPosition + aLength))

			{

			for(index = iNewLineArrayIndex ; index < newLineArrayCount - 1 ; ++index)

				{

				TInt alamakota= iNewLineArray[index];

				if(iNewLineArray[index] >= aPosition && 

						iNewLineArray[index] < (aPosition + aLength))

					{

					retVal = iNewLineArray[index] - aPosition;

					iNewLineArrayIndex = index;

					index = newLineArrayCount + 1;

					}

				else if(iNewLineArray[index] > aPosition &&

						iNewLineArray[index] > (aPosition + aLength))

					{

					retVal = -1;

					index = newLineArrayCount + 1;

					}

				}

			}

		else

			{

			for(index = iNewLineArrayIndex ; index >= 0  ; --index)

				{

				TInt alamakota= iNewLineArray[index];

				if(iNewLineArray[index] >= aPosition && 

						iNewLineArray[index] < (aPosition + aLength))

					{

					retVal = iNewLineArray[index] - aPosition;

					iNewLineArrayIndex = index;

					index = 0;

					}

				else if(iNewLineArray[index] > aPosition &&

						iNewLineArray[index] > (aPosition + aLength))

					{

					retVal = -1;

					index = 0;

					}

				}

			}

		return retVal;	

	}

MFsRichTextObject* CFsTextParser::GetNextObjectL()

    {

    MFsRichTextObject* textObject = NULL;

    TInt startPos = 0;

    TInt wordLength = 0;

    FindBlokOfText();

    iGNONextPosition = iPosition + iGNOSomeText.Length(); 

    if(iGNONextPosition  < iText.DocumentLength())

    	{

    	FindNextBlokOfText();

    	if(iGNOCharFormat.IsEqual(iGNOCharFormatOfNextBlock))

    		{

    		TBool connect = ETrue;

    		if(iGNOSomeTextOfNextBlock.Length() == 1)

    			{

    			TBuf<1> checkForSpecialChar;

    			_LIT(specialChar, "\xFFFC");

    			iText.Extract(checkForSpecialChar, iGNONextPosition, 1);

    			if(checkForSpecialChar.Right(1).Compare(specialChar) == 0)

    				{

    				connect = EFalse;

    				}

    			}

    		if(iGNOSomeText.Length() == 1)

    			{

    			TBuf<1> checkForSpecialChar;

    			_LIT(specialChar, "\xFFFC");

    			iText.Extract(checkForSpecialChar, iPosition, 1);

    			if(checkForSpecialChar.Right(1).Compare(specialChar) == 0)

    				{

    				connect = EFalse;

    				}

    			}

    		if(connect)

    			{

    			TInt l1 = iGNOSomeText.Length();

    			TInt l2 = iGNOSomeTextOfNextBlock.Length();

    			TBuf<121> someCharacter;

    			TInt getTextLength = (l1 + l2) > 120 ? 120 : (l1 + l2);

    			iText.Extract(someCharacter, iPosition, getTextLength);

    			iGNOSomeText.Set(someCharacter.Left(someCharacter.Length()));

    			}

    		}

    	}

   	if(iPosition == 0 || iLastPosition != iLastWordPosition || iLastLength < 120)

   		{	

   		iText.GetWordInfo(

            iPosition, 

            startPos, 

            wordLength, 

            EFalse, 

            EFalse);    	

   		iLastLength = wordLength;

   		}

   	if(iGNOSomeText.Length() > 100)

   		{

   		//iGNOSomeText.Set(iText.Read(iPosition,100));

   		iGNOSomeText.Set(iGNOSomeText.Mid(0, 100));

        iLastLength -= 100;

        //wordLength = 100;

        //startPos = iPosition;

   		}

   	iLastWordPosition = iPosition;

   	if ( !wordLength )

   		{

   		wordLength = iNewLengthOfWord != 0 ? iNewLengthOfWord : 0;

   		startPos = iPosition;

   		}

   	TInt a1 = iGNOSomeText.Length();

   	TInt a2 = startPos + wordLength - iPosition + 1;

    if(a1 > a2)

        {

        //iGNOSomeText.Set(iText.Read(iPosition,startPos + wordLength - iPosition + 1));