// Copyright (c) 1998-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:

//

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

inline LOCAL_C void AppendCRLF( TDes8& rOutputLine, TInt& rPaddingCount )

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

	{

	rOutputLine.Append( TPtrC8(KImcvCRLF) );

	rPaddingCount += KImcvCRLF().Length();

	}

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

inline LOCAL_C TInt AddCRLF(TDes8& rOutputLine)

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

	{

	rOutputLine = KImcvCRLF;

	return 1;

	}

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

inline LOCAL_C void AddCRLF( TDes8& rOutputLine, TInt& rPaddingCount )

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

	{

	rOutputLine=TPtrC8(KImcvCRLF);

	rPaddingCount = KImcvCRLF().Length();

	}

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

inline LOCAL_C void AddCRLFAtEndOfLine( TDes8& rOutputLine, TInt& rPaddingCount)

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

	{

	TInt length = rOutputLine.Length();

	if ( length < 2 || (rOutputLine[length-2] != KImcvCR || rOutputLine[length-1] != KImcvLF) )

		{

		rOutputLine.Append( KImcvCRLF );

		rPaddingCount += 2;

		}

	}

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

inline TBool IsLineCRLF( TDesC8& aOutputLine )

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

	{

	TInt length = aOutputLine.Length();

	if ( length < 2 || (aOutputLine[length-2] != KImcvCR || aOutputLine[length-1] != KImcvLF) )

		return EFalse;

	return ETrue;

	}

//****************************************************************************************

//              Class CImEmailTraverser Functions

//****************************************************************************************

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

inline TInt CImEmailTraverser::CurrentEntry()

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

	{

	return iCurrentEntryList[0];

	}

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

inline CMsvEntrySelection& CImEmailTraverser::CurrentList() const

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

	{

	return *(*iSelectionList)[0];

	}

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

inline TBool CImEmailTraverser::DeleteCurrentList()

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

	{

	if (!LevelExists())

		return EFalse;

	delete &CurrentList();

	iSelectionList->Delete(0);

	iCurrentEntryList.Delete(0);

	return ETrue;

	}

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

inline void CImEmailTraverser::AddList(CMsvEntrySelection& children)

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

	{

	iSelectionList->InsertL(0, &children);

	iCurrentEntryList.InsertL(0, 0);

	}

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

inline TBool CImEmailTraverser::LevelExists() const

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

	{

	return iSelectionList->Count();

	}

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

inline TBool CImEmailTraverser::IsBaseLevel() const

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

	{

	return ThisEntry().Id()==iBaseId ? ETrue: EFalse;;

	}

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

inline void CImEmailTraverser::SetBaseEntry()

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

	{

	iServerEntry.SetEntry(iBaseId);

	}

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

inline const TMsvEntry& CImEmailTraverser::ThisEntry() const

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

	{	

	return iServerEntry.Entry();

	}

//****************************************************************************************

//              Class CImSendMimeEmail Functions

//****************************************************************************************

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

inline void CImSendMimeEmail::Boundary(TDes8& rOutputLine) 

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

	{

	rOutputLine.Append( (*iBoundaryArray)[0] );

	}

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

inline TPtrC8 CImSendMimeEmail::Boundary()

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

	{

	return (*iBoundaryArray)[0];

	}

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

inline TInt CImSendMimeEmail::SendBoundaryLine(TDes8& rOutputLine, TInt& rPaddingCount)

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

	{

	rOutputLine.Append(KImcvMimeBoundaryStartEnd);

	Boundary( rOutputLine );

	rPaddingCount += (*iBoundaryArray)[0].Length() + 2;

	return 1;

	}

// Sets iState to EEndBoundary or EEndOfEmail

// returns true if entry found

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

inline TBool CImSendMimeEmail::Down(TMsvEntry& rEntry)

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

	{

	TInt ret = iEmailTraverser->DownLevelL() ? ETrue:EFalse;

	if (ret)

		rEntry = iEmailTraverser->ThisEntry();

	return ret;

	}

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

inline void CImSendMimeEmail::GetNextEntryL(TMsvEntry& rEntry)

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

	{

	if ( (iState!=EEndBoundary && iState!=ELineAfterEndBoundary) && Down(rEntry) )

		iState=EBoundary;

	else if ( iEmailTraverser->NextEntryL(rEntry) )

		iState=EBoundary;

	else if (iEmailTraverser->UpLevelL() )

		{

		if (iServerEntry.Entry().iType==KUidMsvMessageEntry && !(iEmailTraverser->IsBaseLevel()))

			{

			// Embedded non-mime message

			iState=EEndBoundary;

			GetNextEntryL(rEntry);

			}

		else

			iState=EEndBoundary;

		}

	else

		iState=KImCvFinished;

	}

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

inline TPtrC8 CImSendMimeEmail::SetBoundaryL(TBool aMultipart)

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

	{

	if (!aMultipart)

		return TPtrC8();

	CreateBoundaryL();

	return (*iBoundaryArray)[0];

	}

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

inline TBool CImSendMimeEmail::CheckForEmbeddedEmailL(const TMsvEntry& aEntry) const

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

	{

	return (aEntry.iType==KUidMsvMessageEntry);

	}

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

inline TBool CImSendMimeEmail::CheckForMultipartEmailL(TMsvEntry& rEntry, TImEmailFolderType& aFolder)

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

	{

	TMsvEmailEntry emailEntry = (TMsvEmailEntry)rEntry;

	aFolder = emailEntry.MessageFolderType();

	if (aFolder==EFolderTypeMixed || aFolder==EFolderTypeDigest || 

		aFolder==EFolderTypeAlternative || aFolder==EFolderTypeRelated ) 

		return ETrue;

	if ( ! Down(emailEntry) )

		return EFalse;

	if ( iEmailTraverser->CurrentList().Count()==1 && 

				iEmailTraverser->ThisEntry().iType==KUidMsvFolderEntry )

		{

		aFolder = ((TMsvEmailEntry&)iEmailTraverser->ThisEntry()).MessageFolderType();

		iEmailTraverser->UpLevelL();

		return ETrue;

		}

	iEmailTraverser->UpLevelL();

	return EFalse;

	}

//****************************************************************************************

//              Class CImSendRfc822Header Functions

//****************************************************************************************

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

inline TInt CImSendRfc822Header::XMailerL(TDes8& rOutputLine)

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

	{

	rOutputLine = KImcvXMailer;

	rOutputLine.Append(*iProductName);

	return 1;

	}

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

inline TInt CImSendRfc822Header::MessageIdL( TDes8& rOutputLine )

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

	{

	if ( !iHeader->ImMsgId().Length() )

		return 1;

	PrepareBufferL( TPtrC8(KImcvMessageIdPrompt), iHeader->ImMsgId());

	return SendOutput( rOutputLine );

	}

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

inline TInt CImSendRfc822Header::ToL(TDes8& rOutputLine)

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

	{

	return DoRecipientsL(rOutputLine, TPtrC8(KImcvToPrompt), iHeader->ToRecipients());

	}

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

inline TInt CImSendRfc822Header::CcL(TDes8& rOutputLine)

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

	{

	return DoRecipientsL(rOutputLine, TPtrC8(KImcvCcPrompt), iHeader->CcRecipients());

	}

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

inline TInt CImSendRfc822Header::BccL(TDes8& rOutputLine)

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

	{

	return DoRecipientsL(rOutputLine, TPtrC8(KImcvBccPrompt), iHeader->BccRecipients());

	}

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

inline TInt CImSendRfc822Header::FromL( TDes8& rOutputLine )

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

	{

	PrepareBufferL( TPtrC8(KImcvFromPrompt), iHeader->From());

	return SendOutput( rOutputLine );

	}

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

inline TInt CImSendRfc822Header::ReplyToL( TDes8& rOutputLine )

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

	{

	if ( !iHeader->ReplyTo().Length() )

		return 1;

	PrepareBufferL( TPtrC8(KImcvReplyToPrompt), iHeader->ReplyTo() );

	return SendOutput( rOutputLine );

	}

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

inline TInt CImSendRfc822Header::SubjectL( TDes8& rOutputLine )

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

	{

	// If the subject field has already been encoded and stored in iOutputBuffer

	// then there is no need to encode again.

	if (!iOutputBuffer)

		{

		PrepareBufferL( TPtrC8(KImcvSubjectPrompt), iHeader->Subject() );

		}

	return SendOutput( rOutputLine );	

	}

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

inline TInt CImSendRfc822Header::ReturnReceiptsL(TDes8& rOutputLine)

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

	{

	// SendReturnReceiptFieldsL() will always return one choice. 

	// In future it can be changed to add more fields 

	TPtrC address;

	if ( iHeader->ReceiptAddress().Length() )

		address.Set(iHeader->ReceiptAddress());

	else if ( iHeader->ReplyTo().Length() )

		address.Set(iHeader->ReplyTo());

	else

		return 1; // No valid a address

	CDesC8Array* receiptsFields=new (ELeave)CDesC8ArrayFlat(KArrayAllocationNumber);

	CleanupStack::PushL(receiptsFields);

	CImcvUtils::SendReturnReceiptFieldsL(*receiptsFields);

	TInt count=receiptsFields->Count();

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

		PrepareBufferL((*receiptsFields)[i], address);

	CleanupStack::PopAndDestroy(); //receiptsFields

	return SendOutput( rOutputLine );

	}

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

inline TBool CImSendRfc822Header::FieldIsEmailAddress() const

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

	{

	return (iState != ESubject);

	}

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

inline const TImEmailTransformingInfo& CImSendRfc822Header::TransformingInfo() const

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

	{

	return iTransformingInfo;

	}

//****************************************************************************************

//              Class CImSendMimeHeader Functions

//****************************************************************************************

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

inline TInt CImSendMimeHeader::BlankLine(TDes8& rOutputLine) const

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

	{

	rOutputLine = KNullDesC8;

	return 1;

	}

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

inline TInt CImSendMimeHeader::MimeVersion(TDes8& rOutputLine) const

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

	{

	rOutputLine = KImcvMimePrompt;

	rOutputLine.Append(KImcvSpMimeVersion);

	return 1;

	}

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

inline TBool CImSendMimeHeader::ContentType(TDes8& rOutputLine) const

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

	{

	TBool isText = EFalse;

	rOutputLine = KImcvContentType;

	rOutputLine.Append(KImcvSpace);

	if (((TMsvEmailEntry&)iEntry).VCard())

		{

		rOutputLine.Append(KImcvText);

		rOutputLine.Append( KImcvForwardSlash );

		rOutputLine.Append(KImcvDirectory);

		rOutputLine.Append( KImcvSemiColon );

		rOutputLine.Append( KImcvSpace );

		rOutputLine.Append( KImcvProfile );

		rOutputLine.Append( KImcvEquals );

		rOutputLine.Append( KImcvVCard );

		isText=ETrue;

		}

	else if (((TMsvEmailEntry&)iEntry).VCalendar())

		{

		rOutputLine.Append(KImcvText);

		rOutputLine.Append( KImcvForwardSlash );

		rOutputLine.Append(KImcvVCalender);

		isText=ETrue;

		}

	else if (iEntry.iType == KUidMsvEmailHtmlEntry)

		{

		rOutputLine.Append(KImcvText);

		rOutputLine.Append( KImcvForwardSlash );

		rOutputLine.Append(KImcvHtml);

		isText=ETrue;

		}

	else if ( iMimeHeader->ContentType().Length() )

		{

		TPtrC8 contentType = iMimeHeader->ContentType();

		rOutputLine.Append( contentType );	

		TPtrC8 contentSubType = iMimeHeader->ContentSubType();

		if ( contentSubType.Length() )

			{

			rOutputLine.Append( KImcvForwardSlash );

			rOutputLine.Append( iMimeHeader->ContentSubType() );

			}

		isText = contentType.CompareF(KImcvText) ? EFalse : ETrue;

		// If the content-Type is text/calendar we need to add two

		// parameters: "method" and "component"

// GS : do we need extra parameters for vCal??

		TPtrC8 parameter;

		if ( contentType.Length() && contentSubType.Length() )

		if ( isText && !(contentSubType.CompareF(KImcvICalendar)) )

			{

			// METHOD parameter

			parameter.Set(iMimeHeader->GetContentTypeValue(KImcvICalendarMethod));

			if ( parameter.Length() )

				{

				rOutputLine.Append( KImcvSemiColon );

				rOutputLine.Append( KImcvSpace );

				rOutputLine.Append( KImcvICalendarMethod );

				rOutputLine.Append( KImcvEquals );

				rOutputLine.Append( parameter );

				}

			// COMPONENT parameter

			parameter.Set(iMimeHeader->GetContentTypeValue(KImcvICalendarComponent));

			if ( parameter.Length() )

				{

				rOutputLine.Append( KImcvSemiColon );

				rOutputLine.Append( KImcvSpace );

				rOutputLine.Append( KImcvICalendarComponent );

				rOutputLine.Append( KImcvEquals );

				rOutputLine.Append( parameter );

				}	

			}

		}

	else if (iEntry.iType == KUidMsvAttachmentEntry)

		rOutputLine.Append( KImcvApplOctet );	

	else if (iEntry.iType==KUidMsvEmailTextEntry || (!iIsMultipart && !iEntry.Attachment()))

		{

		rOutputLine.Append(KImcvText);

		rOutputLine.Append( KImcvForwardSlash );

		rOutputLine.Append(KImcvPlain);

		isText=ETrue;

		}

	else

		{

		rOutputLine.SetLength(0);

		return EFalse;

		}

	if (isText)

		{

		rOutputLine.Append( KImcvSemiColon );

		rOutputLine.Append( KImcvSpace );

		rOutputLine.Append( KImcvCharset );

		rOutputLine.Append( KImcvEquals );

		rOutputLine.Append( GetCharsetString() );

		}

	else if ( iBoundaryString.Length() )

		rOutputLine.Append(KImcvSemiColon); // boundary to follow

	return ETrue;

	}

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

inline TBool CImSendMimeHeader::TransferEncoding(TDes8& rOutputLine) const

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

	{

	TPtrC8 encodingType = EncodingType();

	if (iEntry.iType!=KUidMsvFolderEntry && encodingType.Length())

		{

		rOutputLine = KImcvContentTransferEncoding;

		rOutputLine.Append(encodingType);

		return ETrue;

		}

	return EFalse;

	}

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

inline TInt CImSendMimeHeader::ContentLanguage(TDes8& rOutputLine) const

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

	{

	rOutputLine = KImcvContentLanguage;

	rOutputLine.Append(KImcvDefaultLanguage);

	return 1;

	}

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

inline TBool CImSendMimeHeader::Description( TDes8& rOutputLine ) const

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

	{

	TPtrC8 description = iMimeHeader->ContentDescription();

	if ( !description.Length() )

		return EFalse;