// Copyright (c) 2001-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 "CHtmlToCrtConvActionProcessor.h"

#include "CHtmlToCrtConvActionProcessorCustom.h"

#include "CHtmlToCrtConvHash.h"

CHtmlToCrtConvActionProcessor* CHtmlToCrtConvActionProcessor::NewL(CRichText& aRichText, MHtmlToCrtConvResourceFile& aResourceFile)

	{

	CHtmlToCrtConvActionProcessor* self=new(ELeave) CHtmlToCrtConvActionProcessor(aRichText, aResourceFile);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CHtmlToCrtConvActionProcessor::ConstructL()

	{

	iParaFormat=new(ELeave) CParaFormat;

	}

CHtmlToCrtConvActionProcessor::CHtmlToCrtConvActionProcessor(CRichText& aRichText, MHtmlToCrtConvResourceFile& aResourceFile)

:iText(aRichText)

,iResourceFile(aResourceFile)

	{

	}

CHtmlToCrtConvActionProcessor::~CHtmlToCrtConvActionProcessor()

	{

	delete iParaFormat;

	}

//==========================================================================

//utility functions

//==========================================================================

void CHtmlToCrtConvActionProcessor::DoBlockLevelTagActionL()

	{

	InsertParagraphDelimiterL();

	ApplyAlignmentL();

	}

void CHtmlToCrtConvActionProcessor::ApplyAlignmentL()

	{

 	if (IsFlagSet(EAlignAttribPending))

		{

		iText.ApplyParaFormatL(iParaFormat, iParaFormatMask, iAlignmentStartPosition, (iTextPosition-iAlignmentStartPosition));

		iParaFormatMask.ClearAttrib(EAttAlignment);

		ClearFlag(EAlignAttribPending);

		}

	}

void CHtmlToCrtConvActionProcessor::InsertParagraphDelimiterL()

	{

	if(iTextPosition>1)

		{

		//get last 2 significant characters from the richtext object, ie ignore white space characters except for paragraph delimiter

		TBuf<2> lastTwoCharacters;

		TInt richTextPosition=iTextPosition-1;//position of last character in rich text

		while(lastTwoCharacters.Length()<2 && richTextPosition>=0)

			{

			//get character at position richTextPosition from rich text

			TPtrC ptrCurrentCharacter=iText.Read(richTextPosition--, 1);

			TChar currentCharacter=(ptrCurrentCharacter)[0];

			if(!(currentCharacter.IsSpace() && currentCharacter!=CEditableText::EParagraphDelimiter))

				{

				lastTwoCharacters.Append(currentCharacter);

				}

			}

		TBuf<2> twoParagraphDelimiters;

		twoParagraphDelimiters.Append(CEditableText::EParagraphDelimiter);

		twoParagraphDelimiters.Append(CEditableText::EParagraphDelimiter);

		if(lastTwoCharacters.Compare(twoParagraphDelimiters))

			{

			iText.InsertL(iTextPosition, CEditableText::EParagraphDelimiter);

			iTextPosition+=1;

			}

		}

	else

		{

		iText.InsertL(iTextPosition, CEditableText::EParagraphDelimiter);

		iTextPosition+=1;

		}

	}

//==========================================================================

//DoWriteTextL

//==========================================================================

void CHtmlToCrtConvActionProcessor::DoWriteTextL(const TDesC16& aText)

	{

	if (!IsFlagSet(EIgnoreText))

		{

 		HBufC* temp=HBufC::NewLC(aText.Length());

		TPtr tempPtr(temp->Des());

 		tempPtr.Copy(aText);

		//trim buffer, leaving one space at start and end of the buffer

		TrimBufferL(tempPtr);

 		iText.InsertL(iTextPosition, *temp);

 		CleanupStack::PopAndDestroy(temp);

		iTextPosition=iText.DocumentLength();

		//CancelInsertCharFormat cancels the "insert pending" state set by a call to SetInsertCharFormatL() or DelSetInsertCharFormatL().

		//This removes the restriction on the text insertion position, and has no effect if not applicable.

		iText.CancelInsertCharFormat();

		}

	}

//==========================================================================

//TrimBufferL

//==========================================================================

void CHtmlToCrtConvActionProcessor::TrimBufferL(TPtr& aPtr)

	{

	TInt len=aPtr.Length();

	if	(!len)

		return;

	// Current document length - required so that we don't insert

	// any spaces until we come across a first run of text.

	const TInt documentLength=iText.DocumentLength();

	//check if first and last characters are white space characters

	TBool spaceAtStart=EFalse;

	TBool spaceAtEnd=EFalse;

	TChar left=(aPtr)[0];

	TChar right=(aPtr)[len-1];

	if(documentLength>0 && left.IsSpace())

		{

		spaceAtStart=ETrue;

		//if length is 1 we are seeing the same space twice,

		//if length is 2 then only one space is required

		if(len>2 && right.IsSpace())

			{

			spaceAtEnd=ETrue;

			}

		}

	else if(right.IsSpace())

		{

		spaceAtEnd=ETrue;

		}

	//remove leading and trailing space characters, and replace each contiguous set of space characters by one space character

	aPtr.TrimAll();

	//add space character at start/end of buffer, if required

	_LIT(KSpace, " ");

	if(spaceAtStart)

		{

		aPtr.Insert(0, KSpace);

		}

	if(spaceAtEnd)

		{

		aPtr.Append(KSpace);

		}

	// Convert any remaining carriage returns or line feeds to spaces

	const TText KSpaceCharacter=0x20;

	const TText KCarriageReturn=0x0d;

	const TText KLineFeed=0x0a;

	TText* pText=const_cast<TText*>(aPtr.Ptr());

	for(TInt ii=0; ii<len; ii++)

		{

		if	(pText[ii]==KCarriageReturn || pText[ii]==KLineFeed)

			pText[ii]=KSpaceCharacter;

		}

	}

//==========================================================================

//SetFontStrokeWeightL

//==========================================================================

void CHtmlToCrtConvActionProcessor::SetFontStrokeWeightL(TFontStrokeWeight aStrokeWeight)

	{

	if(!(iCharFormat.iFontSpec.iFontStyle.StrokeWeight()==aStrokeWeight))

		{

		iCharFormatMask.SetAttrib(EAttFontStrokeWeight);

		iCharFormat.iFontSpec.iFontStyle.SetStrokeWeight(aStrokeWeight);

		iText.SetInsertCharFormatL(iCharFormat, iCharFormatMask, iTextPosition);

		}

	}

//==========================================================================

//SetFontPostureL

//==========================================================================

void CHtmlToCrtConvActionProcessor::SetFontPostureL(TFontPosture aFontPosture)

	{

	if(!(iCharFormat.iFontSpec.iFontStyle.Posture()==aFontPosture))

		{

		iCharFormatMask.SetAttrib(EAttFontPosture);

		iCharFormat.iFontSpec.iFontStyle.SetPosture(aFontPosture);

		iText.SetInsertCharFormatL(iCharFormat, iCharFormatMask, iTextPosition);

		}

	}

//==========================================================================

//SetFontUnderlineL

//==========================================================================

void CHtmlToCrtConvActionProcessor::SetFontUnderlineL(TFontUnderline aFontUnderline)

	{

	if(!(iCharFormat.iFontPresentation.iUnderline==aFontUnderline))

		{

		iCharFormatMask.SetAttrib(EAttFontUnderline);

		iCharFormat.iFontPresentation.iUnderline=aFontUnderline;

		iText.SetInsertCharFormatL(iCharFormat, iCharFormatMask, iTextPosition);

		}

	}

//==========================================================================

//SetFontPrintPositionL

//==========================================================================

void CHtmlToCrtConvActionProcessor::SetFontPrintPositionL(TFontPrintPosition aFontPrintPosition)

	{

	if(!(iCharFormat.iFontSpec.iFontStyle.PrintPosition()==aFontPrintPosition))

		{

		iCharFormatMask.SetAttrib(EAttFontPrintPos);

		iCharFormat.iFontSpec.iFontStyle.SetPrintPosition(aFontPrintPosition);

		iText.SetInsertCharFormatL(iCharFormat, iCharFormatMask, iTextPosition);

		}

	}

//==========================================================================

//SetFontStrikethroughL

//==========================================================================

void CHtmlToCrtConvActionProcessor::SetFontStrikethroughL(TFontStrikethrough aFontStrikethrough)

	{

	if(!(iCharFormat.iFontPresentation.iStrikethrough==aFontStrikethrough))

		{

		iCharFormatMask.SetAttrib(EAttFontStrikethrough);

		iCharFormat.iFontPresentation.iStrikethrough=aFontStrikethrough;

		iText.SetInsertCharFormatL(iCharFormat, iCharFormatMask, iTextPosition);

		}

	}

//==========================================================================

//SetFontTextColorL

//==========================================================================

void CHtmlToCrtConvActionProcessor::SetFontTextColorL(const TRgb& aFontTextColor)

	{

	if(!(iCharFormat.iFontPresentation.iTextColor==aFontTextColor))

		{

		iCharFormatMask.SetAttrib(EAttColor);

		iCharFormat.iFontPresentation.iTextColor=aFontTextColor;

		iText.SetInsertCharFormatL(iCharFormat, iCharFormatMask, iTextPosition);

		}

	}

//==========================================================================

//SetFontSizeL

//==========================================================================

void CHtmlToCrtConvActionProcessor::SetFontSizeL(TInt aFontSizeInTwips)

	{

	if(!(iCharFormat.iFontSpec.iHeight==aFontSizeInTwips))

		{

		iCharFormatMask.SetAttrib(EAttFontHeight);

		iCharFormat.iFontSpec.iHeight=aFontSizeInTwips;

		iText.SetInsertCharFormatL(iCharFormat, iCharFormatMask, iTextPosition);

		}

	}

//==========================================================================

//DoTagActionL

//==========================================================================

void CHtmlToCrtConvActionProcessor::DoTagActionL(THtmlToCrtConvTagType aTagType, CHtmlToCrtConvParser::TTagState aTagState)

	{

	ASSERT(aTagState!=CHtmlToCrtConvParser::ENoTag);

	switch(aTagType)

		{

//BLOCK LEVEL ELEMENTS

		case EHtmlTagH1:

			DoHeaderL(aTagState, KH1SizeInTwips);

			break;

		case EHtmlTagH2:

			DoHeaderL(aTagState, KH2SizeInTwips);

			break;

		case EHtmlTagH3:

			DoHeaderL(aTagState, KH3SizeInTwips);

			break;

		case EHtmlTagH4:

			DoHeaderL(aTagState, KH4SizeInTwips);

			break;

		case EHtmlTagH5:

			DoHeaderL(aTagState, KH5SizeInTwips);

			break;

		case EHtmlTagH6:

			DoHeaderL(aTagState, KH6SizeInTwips);

			break;

		case EHtmlTagCenter:

			DoCenterL(aTagState);

			break;

		case EHtmlTagBlockquote:

			DoBlockquoteL(aTagState);

			break;

		case EHtmlTagForm:

			DoFormL(aTagState);

			break;

		case EHtmlTagUnorderedList:

			DoUnorderedListL(aTagState);

			break;

		case EHtmlTagOrderedList:

			DoUnorderedListL(aTagState);

			break;

		case EHtmlTagDefinitionList:

			DoUnorderedListL(aTagState);

			break;

		case EHtmlTagParagraph:

			DoParagraphL();

			break;

		case EHtmlTagTable:

			DoTableL();

			break;

		case EHtmlTagDivision:

			DoDivisionL();

			break;

		case EHtmlTagPreformatted:

			DoPreformattedL();

			break;

		case EHtmlTagHorizontalRule:

			DoHorizontalRuleL();

			break;

		case EHtmlTagHtml:

			DoHtmlL(aTagState);

			break;

//TEXT LEVEL ELEMENTS

		case EHtmlTagTitle:

			DoTitleL(aTagState);

			break;

		case EHtmlTagItalic:

			DoItalicL(aTagState);

			break;

		case EHtmlTagBold:

			DoBoldL(aTagState);

			break;

		case EHtmlTagUnderline:

			DoUnderlineL(aTagState);

			break;

		case EHtmlTagEmphasis:

			DoItalicL(aTagState);

			break;

		case EHtmlTagStrong:

			DoBoldL(aTagState);

			break;

		case EHtmlTagDefinition:

			DoItalicL(aTagState);

			break;

		case EHtmlTagVariable:

			DoItalicL(aTagState);

			break;

		case EHtmlTagCitation:

			DoItalicL(aTagState);

			break;

		case EHtmlTagSubscript:

			DoSubscriptL(aTagState);

			break;

		case EHtmlTagSuperscript:

			DoSuperscriptL(aTagState);

			break;

		case EHtmlTagStrikethrough:

			DoStrikethroughL(aTagState);

			break;

		case EHtmlTagBreak:

			DoBreakL(aTagState);

			break;

		case EHtmlTagCaption:

			DoCaptionL(aTagState);

			break;

		case EHtmlTagTableData:

			DoTableDataL(aTagState);

			break;

		case EHtmlTagTableHeader:

			DoTableDataL(aTagState);

			break;

		case EHtmlTagListItem:

			DoListItemL(aTagState);

			break;

		case EHtmlTagDefinitionTerm:

			DoListItemL(aTagState);

			break;

		case EHtmlTagDefinitionDefinition:

			DoListItemL(aTagState);

			break;

		default:

			break;

		}

	}

//=================================================

//DoAttributeActionL

//=================================================

void CHtmlToCrtConvActionProcessor::DoAttributeActionL(THtmlToCrtConvTagType aTagType, CHtmlToCrtConvParser::TTagState aTagState, const THtmlToCrtConvAttributeType& aType, const TDesC8& aValue, TBool& aImgTagResourceReqd)

	{

	switch(aType)

		{

		case EHtmlAttributeAlign:

			DoAlignL(aValue, aTagState);

			break;

		case EHtmlAttributeHref:

			if (aTagType==EHtmlTagAnchor)

				{

				DoShowUrlL(aValue, aTagState, aTagType);

				}

			break;

		case EHtmlAttributeSrc:

			if (aTagType==EHtmlTagImage)

				{

				DoShowUrlL(aValue, aTagState, aTagType);

				if(IsFlagSet(ESeenAltAttribute))

					{

					aImgTagResourceReqd=EFalse;

					ClearFlag(ESeenAltAttribute);

					}

				else

					aImgTagResourceReqd=ETrue;

				}

			break;

		case EHtmlAttributeAlt:

			if (aTagType==EHtmlTagImage)

				{

				DoAltL(aValue, aTagState);

				aImgTagResourceReqd=EFalse;

				SetFlag(ESeenAltAttribute);

				}

			break;

		default:

			break;

		}

	}

//=======================================================================

//=======================================================================

// TAGS - implementation of

//

// DoHeaderL, DoTitleL, DoShowUrlL, DoAltL

//

// in CHtmlToCrtConvActionProcessorCustom.cpp

//=======================================================================

//

//EHtmlTagCenter

//

void CHtmlToCrtConvActionProcessor::DoCenterL(CHtmlToCrtConvParser::TTagState aTagState)

	{

	DoBlockLevelTagActionL();

	if (aTagState==CHtmlToCrtConvParser::EOpeningTag)

		{

		iParaFormatMask.SetAttrib(EAttAlignment);

		iParaFormat->iHorizontalAlignment=CParaFormat::ECenterAlign;

		iAlignmentStartPosition=iTextPosition;

		SetFlag(EAlignAttribPending);

		}

	}

//

//EHtmlTagBlockquote

//

void CHtmlToCrtConvActionProcessor::DoBlockquoteL(CHtmlToCrtConvParser::TTagState aTagState)

	{

	DoBlockLevelTagActionL();

	if (aTagState==CHtmlToCrtConvParser::EOpeningTag)

		{

		iParaFormatMask.SetAttrib(EAttLeftMargin);

		iParaFormat->iLeftMarginInTwips=KBlockquoteIndentSizeInTwips;

		iBlockquoteStartPosition=iTextPosition;

		SetFlag(EBlockquotePending);

		}

	else if (aTagState==CHtmlToCrtConvParser::EClosingTag && IsFlagSet(EBlockquotePending))

		{

		iText.ApplyParaFormatL(iParaFormat, iParaFormatMask, iBlockquoteStartPosition, (iTextPosition-iBlockquoteStartPosition));

		iParaFormatMask.ClearAttrib(EAttLeftMargin);

		ClearFlag(EBlockquotePending);

		}

	}

//

//EHtmlTagForm

//

void CHtmlToCrtConvActionProcessor::DoFormL(CHtmlToCrtConvParser::TTagState aTagState)

	{

	DoBlockLevelTagActionL();

	if (aTagState==CHtmlToCrtConvParser::EOpeningTag)

		{

		SetFlag(EIgnoreText);

		}

	else if (aTagState==CHtmlToCrtConvParser::EClosingTag)

		{

		ClearFlag(EIgnoreText);

		}

	}

//

//EHtmlTagUnorderedList

//

void CHtmlToCrtConvActionProcessor::DoUnorderedListL(CHtmlToCrtConvParser::TTagState aTagState)

	{

	DoBlockLevelTagActionL();

	if (aTagState==CHtmlToCrtConvParser::EClosingTag && IsFlagSet(EListPending))

		{

		iText.ApplyParaFormatL(iParaFormat, iParaFormatMask, iListStartPosition, (iTextPosition-iListStartPosition));

		iParaFormatMask.ClearAttrib(EAttBullet);

		ClearFlag(EListPending);

		}

	}

//

//EHtmlTagParagraph

//

void CHtmlToCrtConvActionProcessor::DoParagraphL()

	{

	DoBlockLevelTagActionL();

	}

//

//EHtmlTagTable

//

void CHtmlToCrtConvActionProcessor::DoTableL()

	{

	DoBlockLevelTagActionL();

	}

//

//EHtmlTagDivision

//

void CHtmlToCrtConvActionProcessor::DoDivisionL()

	{

	DoBlockLevelTagActionL();