FCL/sf/app/messaging: comparison email/pop3andsmtpmtm/clientmtms/src/MIUTMSG.CPP

equal deleted inserted replaced

--1:000000000000
+:72b543305e3a
+// 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:
+// MIUTMSG.CPP
+//
+#include <e32def.h>
+#include "MIUTMSG.H"
+#include "MIUT_ERR.H"
+#include "IMCMMAIN.H"
+#include "SMTPSET.H"	// CImSmtpSettings
+#include "MIUTRSLV.H"
+#include "MIUTCONV.H"
+#include "POP3SET.H"
+#include "IMAPSET.H"
+#include <msventry.h>
+#include <msvuids.h>
+#include <bautils.h>	// BaflUtils
+#include <barsread.h>	// TResourceReader
+#include <imcm.rsg>
+#include <cntdb.h>
+#include <vcard.h>
+#include <s32mem.h>
+#include <f32file.h>
+#include <apgcli.h> // for recognizeData
+#include <eikenv.h>
+#include <txtrich.h>
+#include <cmsvbodytext.h>
+#include <imcvcodc.h>
+#include <tz.h> //Converting from UTC to local time
+#include <tzconverter.h>
+#include <cmsvplainbodytext.h>
+#include <cmsvattachment.h>
+#include <cmsvmimeheaders.h>
+#include "cimattachmentmanager.h"
+#include <mmsvattachmentmanagersync.h>
+#include <cemailaccounts.h>
+#include "CIMPLAINBODYTEXT.H"
+#include <numberconversion.h>
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include "cimmessagepart.h"
+#include "miut_errconsts.h"
+#include "cimconvertcharconv.h"
+#include "cimconvertheader.h"
+#include <mtmuidsdef.hrh>
+#include "msvconsts.h"
+#endif
+const TInt KMaxChunkLength = 1000;
+const TInt KMiutAttachmentListGranularity=8;
+const TInt KVCardFilenameLength=25;
+const TUid KUidMsgTypePCMail = {0x1000412A};
+const TUid KMessageCharSetStreamUid = {0x101FD0E4};
+const TUint8 KMessageCharSetStreamVersion = 1;
+const TInt KRFC2231Encoded = 2;
+_LIT(KEllipsesString,",...");
+_LIT(KSeparatorString,", ");
+_LIT(KMhtmlUrlAmpersand, "&amp;");
+//
+//CImEmailMessage
+//
+/**
+Allocates and creates a new CImEmailMessage object.
+@param aEntry
+A CMsvEntry object that relates to a message server entry.
+This object is used by CImEmailMessage to perform operations on particular
+message server entries.  It does not matter what context aEntry happens to
+be focused on.
+@return
+A CImEmailMessage message object.
+@see CMsvEntry
+*/
+EXPORT_C CImEmailMessage* CImEmailMessage::NewL(CMsvEntry& aEntry)
+	{
+	CImEmailMessage* self = CImEmailMessage::NewLC(aEntry);
+	CleanupStack::Pop();
+	return self;
+	}
+/**
+Allocates and creates a new CImEmailMessage object, leaving the object on the
+cleanup stack.
+@param aEntry
+A CMsvEntry object that relates to a message server entry.
+This object is used by CImEmailMessage to perform operations on particular
+message server entries.  It does not matter what context aEntry happens to
+be focused on.
+@return
+A CImEmailMessage object.
+@see CMsvEntry
+*/
+EXPORT_C CImEmailMessage* CImEmailMessage::NewLC(CMsvEntry& aEntry)
+	{
+	CImEmailMessage* self = new (ELeave) CImEmailMessage(aEntry);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+/**
+Destructor.
+*/
+EXPORT_C CImEmailMessage::~CImEmailMessage()
+	{
+	Cancel();
+	delete iAttachmentNameList;
+	delete iCompleteSel;
+	delete iResultSel;
+	delete iUriResolver;
+	delete iStoreMessagePart;
+	delete iRemoveMessagePart;
+	iFs.Close();
+	delete iAttachmentManager;
+	delete iStore;
+	}
+CImEmailMessage::CImEmailMessage(CMsvEntry& aEntry)
+	: CMsgActive(EPriorityStandard), iClientEntry(aEntry)
+	{
+	}
+void CImEmailMessage::ConstructL()
+	{
+	iCompleteSel=new (ELeave) CMsvEntrySelection();
+	iResultSel=new (ELeave) CMsvEntrySelection();
+	iUriResolver = CImMhtmlUriResolver::NewL(iClientEntry);
+	iProgress = KMsvNullIndexEntryId;
+	User::LeaveIfError(iFs.Connect());
+	iAttachmentNameList = new (ELeave) CDesCArrayFlat(KMiutAttachmentListGranularity);
+	iEmailEntryId = iClientEntry.EntryId();
+	iAttachmentManager = CImAttachmentManager::NewL(*this,iClientEntry);
+	iAttachmentManager->LoadL();
+	iAttachmentState=ENoAttachment;
+	CActiveScheduler::Add(this);
+	}
+/**
+Asynchronously retrieves the body text for a specified message. If the email's character
+set has been overridden by a prior call to SetCharacterSetL(), the body text is decoded
+with the new character set before it is inserted into the rich text object. A list containing
+the entry Ids for each body text part within the specified message is created during this call.
+The list can be retrieved after this call has completed by calling Selection().
+@param aStatus
+Asynchronous status object (TRequestStatus) that is signalled when the operation
+completes.  aStatus should be checked by the caller to ensure that the operation
+was successful.
+@param aMessageId
+The entry Id of the email message that the body text is to be retrieved from.
+The entry must be of type KUidMsvMessageEntry.
+@param aEntryType
+Specifies whether to search just the email message (EThisMessageOnly),
+or to search within any embedded messages it may contain (EThisMessageAndEmbeddedMessages).
+@param aRichText
+Upon completion, returns the aRichText object that contains the message body text of all text parts found
+for the message entry specified by aMessageId.  If the body text was not found,
+then aRichText will be unchanged.
+@param aParaLayer
+Paragraph format layer for the rich text object specified by aRichText.
+@param aCharLayer
+Character format layer for the rich text object specified by aRichText.
+@leave KErrNotFound
+aMessageId entry could not be located.
+@panic imcm 10
+aMessageId is not of type KUidMsvMessageEntry.
+*/
+EXPORT_C void CImEmailMessage::GetBodyTextL(TRequestStatus& aStatus, TMsvId aMessageId, TImEmailEntryType aEntryType, CRichText& aRichText,CParaFormatLayer& aParaLayer, CCharFormatLayer& aCharLayer)
+	{
+	DoGetBodyTextInitL(aMessageId, aEntryType, aRichText, aParaLayer, aCharLayer);
+	Start(aStatus);
+	}
+/**
+Retrieves the body text for a specified message. If the email's character
+set has been overridden by a prior call to SetCharacterSetL(), the body text is decoded
+with the new character set before it is inserted into the rich text object.
+A list containing the entry Ids for each body text part within the specified message
+is created during this call. The list can be retrieved by calling Selection().
+@param aMessageId
+The entry Id of the email message that the body text is to be retrieved from.
+The entry must be of type KUidMsvMessageEntry.
+@param aEntryType
+Specifies whether to search just the email message (EThisMessageOnly),
+or to search within any embedded messages it may contain (EThisMessageAndEmbeddedMessages).
+@param aRichText
+Returns the aRichText object that contains the message body text of all text parts found
+for the message entry specified by aMessageId.  If the body text was not found,
+then aRichText will be unchanged.
+@param aParaLayer
+Paragraph format layer for the rich text object specified by aRichText.
+@param aCharLayer
+Character format layer for the rich text object specified by aRichText.
+@leave KErrNotFound
+aMessageId entry could not be located.
+@panic imcm 10
+aMessageId is not of type KUidMsvMessageEntry.
+*/
+EXPORT_C void CImEmailMessage::GetBodyTextL(TMsvId aMessageId, TImEmailEntryType aEntryType, CRichText& aRichText,CParaFormatLayer& aParaLayer, CCharFormatLayer& aCharLayer)
+	{
+	DoGetBodyTextInitL(aMessageId, aEntryType, aRichText, aParaLayer, aCharLayer);
+	StartL();
+	}
+void CImEmailMessage::DoGetBodyTextInitL(TMsvId aMessageId, TImEmailEntryType aEntryType, CRichText& aRichText,CParaFormatLayer& aParaLayer, CCharFormatLayer& aCharLayer)
+	{
+	CheckAndInitialiseL(aMessageId);
+	if (aEntryType==EThisMessageOnly)
+		iState=ETextForThisMsg;
+	else if (aEntryType==EThisMessageAndEmbeddedMessages)
+		iState=ETextForMsgDigest;
+	else
+		User::LeaveIfError(KErrNotSupported);
+	iEntryType=aEntryType;
+	iRichText=&aRichText;
+	iParaLayer=&aParaLayer;
+	iCharLayer=&aCharLayer;
+	iCompleteSel->AppendL(iParentMsgId);
+	// Get the new character set if it has been specified.
+	iCharacterSetId = GetOverrideCharacterSetL();
+	}
+EXPORT_C void CImEmailMessage::GetBodyTextEntryIdL(TRequestStatus& aStatus, TMsvId aMessageId, TImEmailEntryType aEntryType)
+	{
+	DoGetBodyTextEntryIdL(aMessageId, aEntryType);
+	Start(aStatus);
+	}
+EXPORT_C void CImEmailMessage::GetBodyTextEntryIdL(TMsvId aMessageId, TImEmailEntryType aEntryType)
+	{
+	DoGetBodyTextEntryIdL(aMessageId, aEntryType);
+	StartL();
+	}
+void CImEmailMessage::DoGetBodyTextEntryIdL(TMsvId aMessageId, TImEmailEntryType aEntryType)
+	{
+	CheckAndInitialiseL(aMessageId);
+	if (aEntryType==EThisMessageOnly)
+		iState=ETextEntryIdForThisMsg;
+	else if (aEntryType==EThisMessageAndEmbeddedMessages)
+		iState=ETextEntryIdMsgDigest;
+	else
+		User::LeaveIfError(KErrNotSupported);
+	iEntryType=aEntryType;
+	iCompleteSel->AppendL(iParentMsgId);
+	}
+/**
+Asynchronously populates a list containing all the attachment entry Ids found that are of a specified
+type belonging to the specified message. After this function has completed, call AttachmentSelection()
+to get the list of found attachments.
+If the email's character set has been overridden by a prior call
+to SetCharacterSetL(), the attachment names are decoded with the new character set.
+@param aStatus
+Asynchronous status object (TRequestStatus) that is signalled when the operation
+completes.  aStatus should be checked by the caller to ensure that the operation
+was successful.
+@param aMessageId
+The entry Id of the email message that the body text is to be retrieved from.
+The entry must be of type KUidMsvMessageEntry.
+@param aAttachmentType
+The type of attachment to find. Supported attachment
+types are EAllAttachments, which would get all attachments for the message,
+EVCards that would get all attachments that are VCards, EVCalendars that would
+get VCalenders, EICalendar that would get ICalendars, and EVEntries which would get
+attachments that are either VCards, VCalendars or ICalendars. EEncrypted, ESigned
+and ESecure are currently not supported.
+@param aEntryType
+Specifies whether to search just the email message (EThisMessageOnly),
+or to search within any embedded messages it may contain (EThisMessageAndEmbeddedMessages).
+@leave KErrNotFound
+aMessageId entry could not be located.
+@panic imcm 10
+aMessageId is not of type KUidMsvMessageEntry.
+@leave KErrNotSupported
+aEntryType is not EThisMessageOnly or EThisMessageAndEmbeddedMessages.
+*/
+EXPORT_C void CImEmailMessage::GetAttachmentsListL(TRequestStatus& aStatus, TMsvId aMessageId, TImAttachmentType aAttachmentType,TImEmailEntryType aEntryType)
+	{
+	DoGetAttachmentsListL(aMessageId, aAttachmentType, aEntryType);
+	Start(aStatus);
+	}
+/**
+Populates a list containing all the attachment entry Ids found that are of a specified
+type belonging to the specified message. After this function has completed, call AttachmentSelection()
+to get the list of found attachments.
+If the email's character set has been overridden by a prior call
+to SetCharacterSetL(), the attachment names are decoded with the new character set.
+@param aMessageId
+The entry Id of the email message that the attachment list is to be populated.
+The entry must be of type KUidMsvMessageEntry.
+@param aAttachmentType
+The type of attachment to find. Supported attachment
+types are EAllAttachments, which would get all attachments for the message,
+EVCards that would get all attachments that are VCards, EVCalendars that would
+get VCalenders, EICalendar that would get ICalendars, and EVEntries which would get
+attachments that are either VCards, VCalendars or ICalendars. EEncrypted, ESigned
+and ESecure are currently not supported.
+@param aEntryType
+Specifies whether to search just the email message (EThisMessageOnly),
+or to search within any embedded messages it may contain (EThisMessageAndEmbeddedMessages).
+@leave KErrNotFound
+aMessageId entry could not be located.
+@panic imcm 10
+aMessageId is not of type KUidMsvMessageEntry.
+@leave KErrNotSupported
+aEntryType is not EThisMessageOnly or EThisMessageAndEmbeddedMessages.
+*/
+EXPORT_C void CImEmailMessage::GetAttachmentsListL(TMsvId aMessageId, TImAttachmentType aAttachmentType,TImEmailEntryType aEntryType)
+	{
+	DoGetAttachmentsListL(aMessageId, aAttachmentType, aEntryType);
+	StartL();
+	}
+void CImEmailMessage::DoGetAttachmentsListL(TMsvId aMessageId, TImAttachmentType aAttachmentType,TImEmailEntryType aEntryType)
+	{
+	CheckAndInitialiseL(aMessageId);
+	iAttachmentManager->AttachmentInfoSelection().ResetAndDestroy();
+	iAttachmentType=aAttachmentType;
+	if (aEntryType==EThisMessageOnly)
+		iState=EAttachmentsForThisMsg;
+	else if (aEntryType==EThisMessageAndEmbeddedMessages)
+		iState=EAttachmentsForMsgDigest;
+	else
+		User::LeaveIfError(KErrNotSupported);
+	iEntryType=aEntryType;
+	iCompleteSel->AppendL(iParentMsgId);
+	}
+/**
+Asynchronously populates a list of embedded message entries contained within the specified message.
+Note that any embedded messages within embedded messages are not included in the list.
+Call Selection() to get the results of the search after it has completed.
+@param aStatus
+Asynchronous status object (TRequestStatus) that is signalled when the operation
+completes.  aStatus should be checked by the caller to ensure that the operation
+was successful.
+@param aMessageId
+The entry Id of the email message that will be searched for embedded messages.
+The entry must be of type KUidMsvMessageEntry.
+@leave KErrNotFound
+aMessageId entry could not be located.
+@panic imcm 10
+aMessageId is not of type KUidMsvMessageEntry.
+*/
+EXPORT_C void CImEmailMessage::GetMessageDigestEntriesL(TRequestStatus& aStatus, TMsvId aMessageId)
+	{
+	CheckAndInitialiseL(aMessageId);
+	iState=EMsgDigestEntries;
+	iCompleteSel->AppendL(iParentMsgId);
+	Queue(aStatus);
+	TRequestStatus* status=&iStatus;
+	iStatus=KRequestPending;
+	User::RequestComplete(status,KErrNone);
+	SetActive();
+	}
+/**
+Asynchronously searches for the starting MHTML part embedded in a multipart/related email message.
+Used when retrieving specific parts of an MHTML message, such as inline images
+that are referenced as MHTML anchors within the HTML part of a message.
+Refer to RFC 2557 - "MIME Encapsulation of Aggregate Documents, such as HTML (MHTML)" for information
+about MHTML email messages.
+If the starting MHTML part cannot be located, then the first HTML part
+that occurs within the multipart/related message is located.
+The result of the search is retrieved by calling GetUniversalResourceIdentifierL() after this methods
+has completed.
+@param aMessageId
+The entry Id of the email message that will be searched.
+@param aStatus
+Asynchronous status object (TRequestStatus) that is signalled when the operation
+completes.  aStatus should be checked by the caller to ensure that the operation
+was successful.
+@leave KErrNotFound
+aMessageId entry could not be located.
+@panic imcm 10
+aMessageId is not of type KUidMsvMessageEntry.
+*/
+EXPORT_C void CImEmailMessage::FindFirstHTMLPageL(TMsvId aMessageId, TRequestStatus& aStatus)
+	{
+	TMsvEntry entry = FindIdEntryL(aMessageId);
+	__ASSERT_ALWAYS(entry.iType==KUidMsvMessageEntry, gPanic(EEntryIsNotMessage));
+	iUriResolver->FindFirstL(aMessageId,ETrue,iStatus);
+	Queue(aStatus);
+	iState = EResolveURI;
+	SetActive();
+	}
+/**
+Asynchronously searches a message entry for an MHTML URI, and resolves it to the message entry that
+contains the message part specified by the URI.
+Used when retrieving specific parts of an MHTML message, such as inline images
+that are referenced as MHTML anchors within the HTML part of a message.
+Refer to RFC 2557 - "MIME Encapsulation of Aggregate Documents, such as HTML (MHTML)" for information
+about MHTML email messages.
+The result of the search is retrieved by calling GetUniversalResourceIdentifierL() after this method
+has completed.
+@param aMessageId
+The message Id of the body part that is to be searched for the URI.
+In the first instance, this value should be the starting MHTML entry Id that was located
+by calling FindFirstHTMLPageL().
+@param aBase
+The base URI to use when searching for aURI if aURI is relative.
+If aBase is empty, and aURI is relative, then the Content-location
+MIME header contained within the HTML part specified by aMessageId is used as a base.
+If the Content-location header does not exist or is not absolute, then
+just the relative aURI is searched for.
+@param aURI
+The absolute or relative URI to resolve.  If aURI is absolute, then aBase is ignored
+and this method completes faster.  If aURI is relative, then aBase is used as a base
+to resolve the relative URI.  If aBase is empty and aURI is relative, then the
+Content-location MIME header contained within the HTML part specified by aMessageId is
+used as the base.  If the Content-location header does not exist or is not absolute, then
+just the relative aURI is searched for.
+@param aStatus
+Asynchronous status object (TRequestStatus) that is signalled when the operation
+completes.  aStatus should be checked by the caller to ensure that the operation
+was successful.
+@leave KErrNotFound
+aMessageId entry could not be located.
+@panic imcm 10
+aMessageId is not of type KUidMsvMessageEntry.
+*/
+EXPORT_C void CImEmailMessage::FindUniversalResourceIdentifierL(TMsvId aMessageId, const TDesC& aBase, const TDesC& aURI, TRequestStatus &aStatus)
+	{
+	TMsvEntry entry = FindIdEntryL(aMessageId);
+	__ASSERT_ALWAYS(entry.iType==KUidMsvEmailHtmlEntry, gPanic(EEntryIsNotMessage));
+	iUriFileFound = EFalse;
+	iUriResolver->ResolveL(aURI, aBase, aMessageId,ETrue,iStatus);
+	Queue(aStatus);
+	iState = EResolveURI;
+	SetActive();
+	}
+/**
+Gets the results from FindUniversalResourceIdentifierL() or FindFirstHTMLPageL()
+method calls when they have completed.
+Used when retrieving specific parts of an MHTML message, such as inline images
+that are referenced as MHTML anchors within the HTML part of a message.
+Refer to RFC 2557 - "MIME Encapsulation of Aggregate Documents, such as HTML (MHTML)" for information
+about MHTML email messages.
+@pre
+FindUniversalResourceIdentifierL() or FindFirstHTMLPageL() must have been called
+prior and completed successfully.
+@param aLinkedEntryId
+Returns the message Id of the message entry that contains the resolved body part, providing
+one is found. Note that you should keep a record of the returned message Id
+as it is required for resolving any URI's that may be found in the resolved body part.
+@param aFileFound
+Returns ETrue if the URI has been resolved and the message entry containing the MHTML part has been
+located. Returns EFalse otherwise.
+@return
+If the URI is resolved, returns the full path specification and file name of the file containing the HTML,
+image, or other such content stored in the message store.  If no file can be located, the absolute URI is returned
+instead.
+*/
+EXPORT_C HBufC* CImEmailMessage::GetUniversalResourceIdentifierL(TMsvId& aLinkedEntryId, TBool& aFileFound) const
+	{
+	aLinkedEntryId = iUriResolver->LinkedEntryId();
+	aFileFound = iUriFileFound;
+	return iUriResolver->FileNameL();
+	}
+/**
+Asynchronously searches for the starting MHTML part embedded in a multipart/related email message.
+Used when retrieving specific parts of an MHTML message, such as inline images
+that are referenced as MHTML anchors within the HTML part of a message.
+Refer to RFC 2557 - "MIME Encapsulation of Aggregate Documents, such as HTML (MHTML)" for information
+about MHTML email messages.
+If the starting MHTML part cannot be located, then the first HTML part
+that occurs within the multipart/related message is located.
+The result of the search is retrieved by calling GetUniversalResourceIdentifierFileHandle() after this methods
+has completed.
+@param aMessageId
+The entry Id of the email message that will be searched.
+@param aStatus
+Asynchronous status object (TRequestStatus) that is signalled when the operation
+completes.  aStatus should be checked by the caller to ensure that the operation
+was successful.
+@leave KErrNotFound
+aMessageId entry could not be located.
+@panic imcm 10
+aMessageId is not of type KUidMsvMessageEntry.
+*/
+EXPORT_C void CImEmailMessage::FindFirstHTMLPageFileHandleL(TMsvId aMessageId, TRequestStatus& aStatus)
+	{
+	TMsvEntry entry = FindIdEntryL(aMessageId);
+	__ASSERT_ALWAYS(entry.iType==KUidMsvMessageEntry, gPanic(EEntryIsNotMessage));
+	iUriResolver->FindFirstL(aMessageId,EFalse,iStatus);
+	Queue(aStatus);
+	iState = EResolveURI;
+	SetActive();
+	}
+/**
+Asynchronously searches a message entry for an MHTML URI, and resolves it to the message entry that
+contains the message part specified by the URI.
+Used when retrieving specific parts of an MHTML message, such as inline images
+that are referenced as MHTML anchors within the HTML part of a message.
+Refer to RFC 2557 - "MIME Encapsulation of Aggregate Documents, such as HTML (MHTML)" for information
+about MHTML email messages.
+The result of the search is retrieved by calling GetUniversalResourceIdentifierFileHandle() after this method
+has completed.
+@param aMessageId
+The message Id of the body part that is to be searched for the URI.
+In the first instance, this value should be the starting MHTML entry Id that was located
+by calling FindFirstHTMLPageFileHandleL().
+@param aBase
+The base URI to use when searching for aURI if aURI is relative.
+If aBase is empty, and aURI is relative, then the Content-location
+MIME header contained within the HTML part specified by aMessageId is used as a base.
+If the Content-location header does not exist or is not absolute, then
+just the relative aURI is searched for.
+@param aURI
+The absolute or relative URI to resolve.  If aURI is absolute, then aBase is ignored
+and this method completes faster.  If aURI is relative, then aBase is used as a base
+to resolve the relative URI.  If aBase is empty and aURI is relative, then the
+Content-location MIME header contained within the HTML part specified by aMessageId is
+used as the base.  If the Content-location header does not exist or is not absolute, then
+just the relative aURI is searched for.
+@param aStatus
+Asynchronous status object (TRequestStatus) that is signalled when the operation
+completes.  aStatus should be checked by the caller to ensure that the operation
+was successful.
+@leave KErrNotFound
+aMessageId entry could not be located.
+@panic imcm 10
+aMessageId is not of type KUidMsvMessageEntry.
+*/
+EXPORT_C void CImEmailMessage::FindUniversalResourceIdentifierFileHandleL(TMsvId aMessageId, const TDesC& aBase, const TDesC& aURI, TRequestStatus &aStatus)
+	{
+	TMsvEntry entry = FindIdEntryL(aMessageId);
+	__ASSERT_ALWAYS(entry.iType==KUidMsvEmailHtmlEntry, gPanic(EEntryIsNotMessage));
+	iUriFileFound = EFalse;
+	//Browsers always append "amp;", when "&" is found while writing URLs in HTML
+	//replacing "&amp;" with "&", before resolving the URLs
+	// eg : if the content location of the image is as below
+	// https://www.ttdm.symbian.com/tmtrack.dll?AttachmentPage&AttachmentID=552810/Morning.jpg
+	// then the browsers writes this to hmtl file by appending "amp;" after "&" because browsers
+	// treat "&" as special character. After apending, the content-location now looks as below
+	// https://www.ttdm.symbian.com/tmtrack.dll?AttachmentPage&amp;AttachmentID=552810/Morning.jpg
+	const TDesC& ampersand = KMhtmlUrlAmpersand;
+	TInt embedUrlIndex;
+	if((embedUrlIndex = aBase.Find(ampersand))!=KErrNotFound)
+		{
+		HBufC* embedUrl = aBase.AllocLC();
+		TPtr embedUrlPtr = embedUrl->Des();
+		embedUrlPtr.Delete(embedUrlIndex+1, 4);
+		iUriResolver->ResolveL(embedUrlPtr, embedUrlPtr, aMessageId,EFalse, iStatus);
+		CleanupStack::PopAndDestroy(); //embedUrl
+		}
+	else
+		{
+		iUriResolver->ResolveL(aURI, aBase, aMessageId,EFalse, iStatus);
+		}
+	Queue(aStatus);
+	iState = EResolveURI;
+	SetActive();
+	}
+/**
+Gets the results from FindUniversalResourceIdentifierFileHandleL() or FindFirstHTMLPageFileHandleL()
+method calls when they have completed.
+Used when retrieving specific parts of an MHTML message, such as inline images
+that are referenced as MHTML anchors within the HTML part of a message.
+Refer to RFC 2557 - "MIME Encapsulation of Aggregate Documents, such as HTML (MHTML)" for information
+about MHTML email messages.
+@pre
+FindUniversalResourceIdentifierFileHandleL() or FindFirstHTMLPageFileHandleL() must have been called
+prior and completed successfully.
+@param aLinkedEntryId
+Returns the message Id of the message entry that contains the resolved body part, providing
+one is found. Note that you should keep a record of the returned message Id
+as it is required for resolving any URI's that may be found in the resolved body part.
+@param aFile
+Returns the file handle of the file containing the HTML,image, or other such
+content stored in the message store if the URI has been resolved. If not then
+this argument is not valid. Ownership is transferred. The caller must close the file handle.
+@return
+If the URI is resolved, returns KErrNone. The output argument aFile is the file
+handle to the content. If no file is located the KErrNotFound is returned and
+aFile is not valid.
+*/
+EXPORT_C TInt CImEmailMessage::GetUniversalResourceIdentifierFileHandle(TMsvId& aLinkedEntryId, RFile& aFile) const
+	{
+	aLinkedEntryId = iUriResolver->LinkedEntryId();
+	return iUriResolver->FileHandle(aFile);
+	}
+/**
+Returns a selection of entries. The entries are either the results of GetMessageDigestEntriesL(),
+or of GetBodyTextL().
+@pre
+GetMessageDigestEntriesL() or GetBodyTextL() must be called prior and successfully completed.
+@return
+Selection of entries populated by GetMessageDigestEntriesL() or GetBodyTextL().
+*/
+EXPORT_C const CMsvEntrySelection& CImEmailMessage::Selection() const
+	{
+	return *iResultSel;
+	}
+/**
+Returns a message entry Id as a type-safe package buffer (TPckg<TMsvId>).
+The meaning of the Id depends on the request as follows:
+AddAttachmentL(), AddMessageAsAttachmentL(), and AddRelatedPartL():
+While the attachment, message, or related part is being added, a null Id
+(KMsvNullIndexEntryId); Once the attachment, message, or related part has been added, the entry Id
+of the newly created attachment, message, or related part.
+DeleteAttachmentL() and DeleteAttachedMessageL(): While the attachment or attached
+message is being removed, a null Id (KMsvNullIndexEntryId); Once the attachment
+or attached message has been removed, the Id of the message from which the
+attachment or attached message was removed.
+StoreBodyTextL(): While the body text is being stored, a null Id (KMsvNullIndexEntryId);
+Once the text has been stored, the Id of the message for which the body text was
+stored.
+@pre
+Call this method after the following asynchronous calls have completed to check progress.
+AddAttachmentL()
+AddMessageAsAttachmentL()
+AddRelatedPartL()
+DeleteAttachmentL()
+DeleteAttachedMessageL()
+StoreBodyTextL()
+@code
+// Example code demonstrating how to retrieve the progress.
+// Create and initialise a temporary TPckg object that can hold a message Id.
+TMsvId msgId;
+TPckg<TMsvId> param(msgId);
+// Copy the message Id returned from the ProgressL() call into the
+// temporary TPckg object.
+param.Copy(emailMsg->ProgressL());  // where emailMsg is of type CImEmailMessage.
+// Check the value of the returned message Id in the TPckg object.
+if (msgId != KMsvNullIndexEntryId)
+	{
+	// More code...
+	}
+@endcode
+@return
+The entry Id as a type-safe packaged buffer (TPckg<TMsvId>).
+*/
+EXPORT_C const TDesC8& CImEmailMessage::ProgressL() const
+	{
+	return iProgress;
+	}
+/**
+Adds a file to a specified message as a MIME multipart/related part. After the
+call has completed, calling ProgressL() will return the Id of the newly created
+related part entry.
+Used when adding specific parts of an MHTML message, such as inline images
+that are referenced as MHTML anchors within the HTML part of a message.
+Refer to RFC 2557 - "MIME Encapsulation of Aggregate Documents, such as HTML (MHTML)" for information
+about MHTML email messages.
+@pre
+This function should only be used on messages created using CImEmailOperation.
+@param aMessageId
+The entry Id of the email message that the related part will be added to.
+The entry must be of type KUidMsvMessageEntry.
+@param aAttachmentFullName
+The full path and file name of the related part file to be copied to the message store.
+If the file cannot be located, this call completes with KErrNotFound.
+@param aStatus
+Asynchronous status object (TRequestStatus) that is signalled when the operation
+completes. aStatus should be checked by the caller to ensure that the operation
+was successful.
+@param aRelatedPartId
+The entry Id of the MHTML message part that the file being added is referenced from.
+@param aContentId
+The Content-Id of the related part.
+@leave KErrNotFound
+aMessageId entry could not be located.
+@panic imcm 10
+aMessageId is not of type KUidMsvMessageEntry.
+*/
+EXPORT_C void CImEmailMessage::AddRelatedPartL(TMsvId aMessageId, const TDesC& aAttachmentFullName, TRequestStatus& aStatus, TMsvId aRelatedPartId, const TDesC8& aContentId)
+	{
+	TMsvEntry entry = FindIdEntryL(aMessageId);
+	__ASSERT_ALWAYS(entry.iType==KUidMsvMessageEntry, gPanic(EEntryIsNotMessage));
+	// adds 'object' with name aAttachmentFullName related to aRelatedPartId in Multipart/Related Folder
+	CImStoreMessagePart* temp = CImStoreMessagePart::AddRelatedPartL(iStatus, iClientEntry, aMessageId, aAttachmentFullName, aRelatedPartId, aContentId);
+	delete iStoreMessagePart;
+	iStoreMessagePart = temp;
+	Queue(aStatus);
+	iState = EStoreMessagePart;
+	SetActive();
+	}
+/**
+Asynchronously stores a body text part for the specified message. After the call
+has completed, calling ProgressL() will return the Id of the message entry for
+which the body text was stored.
+@pre
+This function should only be used on messages created using CImEmailOperation.
+@param aMessageId
+The entry Id of the email message that the body text will be stored in.
+The entry must be of type KUidMsvMessageEntry.
+@param aRichText
+A rich text object (CRichText) that contains the message body text.
+@param aStatus
+Asynchronous status object (TRequestStatus) that is signalled when the operation
+completes. aStatus should be checked by the caller to ensure that the operation
+was successful.
+@leave KErrNotFound
+aMessageId entry could not be located.
+@panic imcm 10
+aMessageId is not of type KUidMsvMessageEntry.
+*/
+EXPORT_C void CImEmailMessage::StoreBodyTextL(TMsvId aMessageId, CRichText& aRichText, TRequestStatus& aStatus)
+	{
+	TMsvEntry entry = FindIdEntryL(aMessageId);
+	__ASSERT_ALWAYS(entry.iType==KUidMsvMessageEntry, gPanic(EEntryIsNotMessage));
+	delete iStoreMessagePart;
+	iStoreMessagePart = NULL;
+	iStoreMessagePart = CImStoreMessagePart::StoreBodyTextL(iStatus, iClientEntry, aMessageId, aRichText);
+	Queue(aStatus);
+	iState = EStoreMessagePart;
+	SetActive();
+	}
+/**
+Asynchronously stores a body text part for the specified message. After the call
+has completed, calling ProgressL() will return the Id of the message entry for
+which the body text was stored.
+@pre
+This function should only be used on messages created using CImEmailOperation.
+@param aMessageId
+The entry Id of the email message that the body text will be stored in.
+The entry must be of type KUidMsvMessageEntry.
+@param aRichText
+A rich text object (CRichText) that contains the message body text.
+@param aStatus
+Asynchronous status object (TRequestStatus) that is signalled when the operation
+completes. aStatus should be checked by the caller to ensure that the operation
+was successful.
+@param aUsePlainTextStorage
+if set to ETrue inidcates that the new message entry needs to be created as plain text
+if set to EFalse indicates that message will be created as richtext entry.
+@leave KErrNotFound
+aMessageId entry could not be located.
+@panic imcm 10
+aMessageId is not of type KUidMsvMessageEntry.
+*/
+EXPORT_C void CImEmailMessage::StoreBodyTextL(TMsvId aMessageId, CRichText& aRichText, TRequestStatus& aStatus, TBool aUsePlainTextStorage)
+	{
+	TMsvEntry entry = FindIdEntryL(aMessageId);
+	__ASSERT_ALWAYS(entry.iType==KUidMsvMessageEntry, gPanic(EEntryIsNotMessage));
+	delete iStoreMessagePart;
+	iStoreMessagePart = NULL;
+	iStoreMessagePart = CImStoreMessagePart::StoreBodyTextL(iStatus, iClientEntry, aMessageId, aRichText, aUsePlainTextStorage);
+	Queue(aStatus);
+	iState = EStoreMessagePart;
+	SetActive();
+	}
+/**
+Asynchronously stores a body text part for the specified message. A Mime header
+is created with the passed in the CImMimeHeader object passed.
+After the call has completed, calling ProgressL() will return the Id of
+the message entry for which the body text was stored.
+@pre
+This function should only be used on messages created using CImEmailOperation.
+@param aMessageId
+The entry Id of the email message that the body text will be stored in.
+The entry must be of type KUidMsvMessageEntry.
+@param aRichText
+A rich text object (CRichText) that contains the message body text.
+@param aMimeHeader
+A MIME header object (CImMimeHeader) that contains the content-type etc.
+@param aStatus
+Asynchronous status object (TRequestStatus) that is signalled when the operation
+completes. aStatus should be checked by the caller to ensure that the operation
+was successful.
+@leave KErrNotFound
+aMessageId entry could not be located.
+@panic imcm 10
+aMessageId is not of type KUidMsvMessageEntry.
+*/
+EXPORT_C void CImEmailMessage::StoreBodyTextWithMimeHeaderL(TMsvId aMessageId, CRichText& aRichText, const CImMimeHeader& aMimeHeader, TRequestStatus& aStatus)
+	{
+	TMsvEntry entry = FindIdEntryL(aMessageId);
+	__ASSERT_ALWAYS(entry.iType==KUidMsvMessageEntry, gPanic(EEntryIsNotMessage));
+	delete iStoreMessagePart;
+	iStoreMessagePart = NULL;
+	iStoreMessagePart = CImStoreMessagePart::StoreBodyTextWithMimeHeaderL(iStatus, iClientEntry, aMessageId, aRichText, aMimeHeader);
+	Queue(aStatus);
+	iState = EStoreMessagePart;
+	SetActive();
+	}
+/**
+Returns the character set Id that the body text will be decoded in when it is
+returned in the call to GetBodyTextL(). It also indicates whether the original
+character set has been overridden by calling SetCharacterSetL().
+@pre
+The store_8bit_body_text flag in imcm.rss should be enabled. This is done at build
+time by the manufacturer.
+@param aMessageId
+The entry Id of the email message that the character set Id is to be retrieved from.
+The entry must be of type KUidMsvMessageEntry.
+@param aCharacterSetId
+Returns the character set Id that the message will be displayed when it is viewed.
+If aCharacterSetId is zero and aOverride is EFalse, the store_8bit_body_text flag
+in imcm.rss has not been enabled.
+@param aOverride
+Returns ETrue if the message's original character set has been overridden (changed)
+via the call to SetCharacterSetL(). If aCharacterSetId is zero and aOverride is EFalse,
+the store_8bit_body_text flag in imcm.rss has not been enabled.
+@leave KErrNotFound
+aMessageId entry could not be located.
+@panic imcm 10
+aMessageId is not of type KUidMsvMessageEntry.
+*/
+EXPORT_C void CImEmailMessage::GetCharacterSetL(TMsvId aMessageId, TUint& aCharacterSetId, TBool& aOverride)
+	{
+	CheckAndInitialiseL(aMessageId);
+	aCharacterSetId = GetOverrideCharacterSetL();
+	if (aCharacterSetId == 0)
+		{
+		// The user has not changed the character set.  Return the body text character set.
+		aOverride = EFalse;
+		iState = ETextForThisMsgGetCharacterSet;
+		iEntryType = EThisMessageOnly;
+		iCompleteSel->AppendL(aMessageId);
+		StartL();
+		aCharacterSetId = iCharacterSetId;
+		}
+	else
+		{
+		aOverride = ETrue;
+		}
+	}
+/**
+Stores the new character set that the message will be displayed as next time
+it is viewed.
+@pre
+The store_8bit_body_text flag in imcm.rss should be enabled. This is done at build
+time by the manufacturer.
+@param aMessageId
+The entry Id of the email message that the character set will be returned from.
+The entry must be of type KUidMsvMessageEntry.
+@param aCharacterSetId
+The character set Id to be stored in the message store.  Setting this value to
+zero will cause the message to be displayed in its original character set when
+it was viewed for the first time after it was downloaded.
+@leave KErrNotFound
+aMessageId entry can not be located in the message store, or the character set
+information can not be located. If the character set information cannot be
+located, it could be because it was not stored when downloaded. To enable this
+functionality set the store_8bit_body_text flag in imcm.rss.
+It is also possible that a call to StoreBodyTextL() has overwritten
+the original character set stored when the message was downloaded.
+@panic imcm 10
+aMessageId is not of type KUidMsvMessageEntry.
+*/
+EXPORT_C void CImEmailMessage::SetCharacterSetL(TMsvId aMessageId, TUint aCharacterSetId)
+	{
+	CheckAndInitialiseL(aMessageId);
+	CMsvStore* store = iClientEntry.EditStoreL();
+	CleanupStack::PushL(store);
+	// If the character set is zero, remove the new character set stream so that the original
+	// character set from the body text will be returned when GetCharacterSetL is called.
+	if (aCharacterSetId == 0)
+		{
+		if (store->IsPresentL(KMessageCharSetStreamUid))
+			{
+			store->RemoveL(KMessageCharSetStreamUid);
+			store->CommitL();
+			}
+		CleanupStack::PopAndDestroy(store);
+		return;
+		}
+	// Write the new character set to the store.
+	RMsvWriteStream out;
+	out.AssignLC(*store, KMessageCharSetStreamUid);
+	out.WriteUint8L(KMessageCharSetStreamVersion);
+	out.WriteUint32L(aCharacterSetId);
+	out.CommitL();
+	store->CommitL();
+	CleanupStack::PopAndDestroy(2, store); //out, store.
+	}
+void CImEmailMessage::CheckAndInitialiseL(TMsvId aMessageId)
+	{
+	iClientEntry.SetEntryNoCheckL(aMessageId);
+	const TMsvEmailEntry& entry=iClientEntry.Entry();
+	__ASSERT_ALWAYS(entry.iType==KUidMsvMessageEntry, gPanic(EEntryIsNotMessage));
+	iParentMsgId=aMessageId;
+	iIsAMHTMLmessage=entry.MHTMLEmail();
+	iCharacterSetId = 0;
+	Reset();
+	}
+void CImEmailMessage::Reset()
+	{
+	iState=EIdle;
+	iCompleteSel->Reset();
+	iResultSel->Reset();
+	iAttachmentManager->AttachmentInfoSelection().ResetAndDestroy();
+	iAttachmentNameList->Reset();
+	}
+void CImEmailMessage::DoCancel()
+	{
+	Reset();
+	iUriResolver->Cancel();
+	if (iStoreMessagePart)
+		iStoreMessagePart->Cancel();
+	if (iRemoveMessagePart)
+		iRemoveMessagePart->Cancel();
+	CMsgActive::DoCancel();
+	}
+void CImEmailMessage::DoComplete(TInt& aStatus)
+	{//set back to the context the user passed in
+	TRAPD(error, iClientEntry.SetEntryL(iParentMsgId));
+if(aStatus == KErrNone)
+	{
+	    aStatus = error;
+	}
+	}
+void CImEmailMessage::DoStateL()
+	{
+	switch (iState)
+		{
+	case EResolveURI:
+		iUriFileFound = (iStatus == KErrNone) ? ETrue : EFalse;
+		iState = EIdle;
+		return;
+	case EStoreMessagePart:
+		iProgress.Copy(iStoreMessagePart->ProgressL());
+		if(iAttachmentState == EAddAttachment || iAttachmentState == ECreateAttachment)
+			{
+			TMsvId attachmentId =  iProgress();
+			iAttachmentManager->AppendAttachmentArrayL(attachmentId);
+			// Once the file is attached to email, reseting the iAttachmentState
+			iAttachmentState = ENoAttachment;
+			}
+		iState = EIdle;
+		return;
+	case ERemoveMessagePart:
+		iProgress.Copy(iRemoveMessagePart->ProgressL());
+		if(iAttachmentState ==  EDeleteAttachment)
+			{
+			TMsvId deletedAttachmentId = iRemoveMessagePart->RemovedAttachmentId();
+			// check whether we currently have a cache of the attachments before
+			// trying to delete the one we have removed.
+			if(iAttachmentManager->AttachmentCount()!=0)
+				{
+				iAttachmentManager->DeleteAttachmentInArrayL(deletedAttachmentId);
+				}
+			}
+		iState = EIdle;
+		return;
+	case EFinished:
+		return;
+	case ETextForThisMsg:
+	case ETextForThisMsgGetCharacterSet:
+	case ETextForMsgDigest:
+	case ETextEntryIdForThisMsg:
+	case ETextEntryIdMsgDigest:
+	case EAttachmentsForThisMsg:
+	case EAttachmentsForMsgDigest:
+	case EMsgDigestEntries:
+		ChangeMessageContextL();
+		break;
+	default:
+		break;
+		};
+	}
+void CImEmailMessage::Start(TRequestStatus& aStatus)
+	{
+	Queue(aStatus);
+	TRequestStatus* status=&iStatus;
+	iStatus=KRequestPending;
+	User::RequestComplete(status,KErrNone);
+	SetActive();
+	}
+void CImEmailMessage::StartL()
+	{
+	TRAPD(error, do DoStateL(); while(iState != EIdle && iState != EFinished););
+	DoComplete(error);
+	User::LeaveIfError(error);
+	}
+void CImEmailMessage::DoRunL()
+	{
+	DoStateL();
+	if (iState != EIdle && iState != EFinished)
+		{
+		TRequestStatus* status=&iStatus;
+		iStatus=KRequestPending;
+		User::RequestComplete(status,KErrNone);
+		SetActive();
+		}
+	}
+/**
+This function takes the first id in iCompleteSel and sets the context to
+that and appends its children to the same list and deletes the id(current) after it has finished with it.
+*/
+void CImEmailMessage::ChangeMessageContextL()
+	{
+	iClientEntry.SetEntryL((*iCompleteSel)[0]);
+	iEntry=iClientEntry.Entry();
+	TUid type=iEntry.iType;
+	TBool searchChildren=ETrue;
+	switch (type.iUid)
+		{
+		case KUidMsvFolderEntryValue:
+			{
+			searchChildren=HandleDifferentFolderTypesL();
+			break;
+			}
+		case KUidMsvAttachmentEntryValue:
+			{
+			if (iState==EAttachmentsForThisMsg || iState==EAttachmentsForMsgDigest)
+				AttachmentInfoL();
+			break;
+			}
+		case KUidMsvEmailTextEntryValue:
+			{
+			switch (iState)
+				{
+				case ETextForThisMsg:
+				case ETextForMsgDigest:
+					{
+					iResultSel->AppendL((*iCompleteSel)[0]);
+					AssembleBodyTextL();
+					break;
+					}
+				case ETextEntryIdForThisMsg:
+				case ETextEntryIdMsgDigest:
+					{
+					iResultSel->AppendL((*iCompleteSel)[0]);
+					break;
+					}
+				case ETextForThisMsgGetCharacterSet:
+					{
+					if (GetBodyTextCharacterSetL())
+						{
+						// Found an 8 bit body text part.  The character set is the
+						// same for every 8 bit body text part so we can return immediately.
+						iCompleteSel->Reset();
+						iState=EFinished;
+						return;
+						}
+					break;
+					}
+				default:
+					{
+					break;
+					}
+				}
+			break;
+			}
+		case KUidMsvMessageEntryValue:
+			{
+			//check if user requested for this entry or digest entry and terminate accordingly.
+			if ((*iCompleteSel)[0]!=iParentMsgId)
+				{
+				// we have a entry attachment, append this to the list of attachments
+				AppendEntryAttachmentInfoL();
+				if (iEntryType==EThisMessageOnly || iState==EMsgDigestEntries)
+					{
+					searchChildren=EFalse;
+					if (iState==EMsgDigestEntries)
+						iResultSel->AppendL((*iCompleteSel)[0]);
+					}
+				}
+			break;
+			}
+		default:
+			{
+			break;
+			}
+		};
+	TInt index=iCompleteSel->Find(iEntry.Id());
+	iCompleteSel->Delete(index);
+	if (searchChildren)
+		CompareChildrenAndPopulateSelL();
+	if (!iCompleteSel->Count())
+		{
+		iState=EFinished;
+		return;
+		}
+	}
+void CImEmailMessage::CompareChildrenAndPopulateSelL()
+	{
+	TKeyArrayFix uidKey(0,ECmpTUint32);
+	iClientEntry.SetSortTypeL(TMsvSelectionOrdering(KMsvNoGrouping,EMsvSortByNone,ETrue));
+	TInt count = iClientEntry.Count();
+	TMsvId id = KMsvNullIndexEntryId;
+	for (TInt i=0; i<count; ++i)
+		{
+		id = iClientEntry[i].Id();
+		if (iCompleteSel->Find(id) == KErrNotFound)
+			{
+			iCompleteSel->InsertIsqL(id ,uidKey);
+			}
+		}
+	}
+void CImEmailMessage::AssembleBodyTextL()
+	{
+	if (!iClientEntry.HasStoreL())
+		return;
+	CMsvStore* store=iClientEntry.ReadStoreL();
+	CleanupStack::PushL(store);
+	if (store->HasBodyTextL())
+		{
+		CRichText* bodyText=CRichText::NewL(iParaLayer,iCharLayer);
+		CleanupStack::PushL(bodyText);
+		store->RestoreBodyTextL(*bodyText, iCharacterSetId);
+		iRichText->AppendTakingSolePictureOwnershipL(*bodyText);
+		CleanupStack::PopAndDestroy(bodyText);
+		}
+	CleanupStack::PopAndDestroy(store);
+	}
+void CImEmailMessage::AttachmentInfoL()
+	{
+	switch (iAttachmentType)
+		{
+	case EAllAttachments: break;
+	case EVCards:
+		if (!iEntry.VCard()) return; break;
+	case EVCalendars:
+		if (!iEntry.VCalendar()) return; break;
+	case EICalendars:
+		if (!iEntry.ICalendar()) return; break;
+	case EVEntries:
+		if (iEntry.VCard() || iEntry.VCalendar() || iEntry.ICalendar()) break; return;
+	case EEncrypted:
+		if (!iEntry.Encrypted()) return; break;
+	case ESigned:
+		if (!iEntry.Signed()) return; break;
+	case ESecure:
+		if (iEntry.Encrypted() || iEntry.Signed()) break; return;
+	default: return;
+		};
+	AppendAttachmentL();
+	}
+/**
+Walking the tree attachments added as found.
+*/
+void CImEmailMessage::AppendAttachmentL()
+	{
+	if(iClientEntry.HasStoreL())
+		{
+		CMsvStore* store = iClientEntry.ReadStoreL();
+		CleanupStack::PushL(store);
+		MMsvAttachmentManager& attachmentMgr = store->AttachmentManagerL();
+		// Modified to handle multiple attachments belonging to a single attachment entry
+		for(TInt i=0;i<attachmentMgr.AttachmentCount();i++)
+			{
+			CMsvAttachment* attachment = attachmentMgr.GetAttachmentInfoL(i);
+			CleanupStack::PushL(attachment);
+			attachment->SetSize(iEntry.iSize);
+			attachment->SetComplete(iEntry.Complete());
+			// For compatibility keep entry [0] as the TMsvId of the owning attachment entry
+			if(i == 0)
+				{
+				attachment->SetId(iClientEntry.EntryId());
+				}
+			else
+				{
+				// Store the index and the owning attachment entry's TMsvId
+				attachment->SetIntAttributeL(KUidMsvEmailAttachmentEntryIndex,i);
+				attachment->SetIntAttributeL(KUidMsvEmailAttachmentEntryId,iClientEntry.EntryId());
+				attachment->SetId(iAttachmentManager->UniqueAttachmentId());
+				}
+			// Add to the per-message list of CMsvAttachments
+			User::LeaveIfError(iAttachmentManager->AttachmentInfoSelection().Append(attachment));
+			// Add the attachment id to the results
+			iResultSel->AppendL(iClientEntry.EntryId());
+			CleanupStack::Pop(attachment);
+			}
+		CleanupStack::PopAndDestroy(store);
+		}
+	AppendAttachmentNameL();
+	}
+/**
+Retrieves the encoded mime header containing the encoded data for the attachment
+name and redecodes with the overriding character set if one has been given. If
+no overriding character set has been specified, a zero length entry is added.
+This indicates whether redcoding is required at retrieval time.
+*/
+void CImEmailMessage::AppendAttachmentNameL()
+	{
+	TMsvId originalId = iClientEntry.EntryId();
+	TUint  overrideCharset = 0;
+	iClientEntry.SetEntryL(iParentMsgId);
+	overrideCharset = GetOverrideCharacterSetL();
+	// Set iClientEntry back to original entry.
+	iClientEntry.SetEntryL(originalId);
+	TFileName filename;
+	TPtrC filenamePtr(KNullDesC);
+	// If our override charset has been set.
+	if (overrideCharset != 0)
+		{
+		CImMimeHeader* mimeHeader = FindAttachmentMimeHeaderL();
+		if (mimeHeader != NULL)
+			{
+			CleanupStack::PushL(mimeHeader);
+			// Decode mime header
+			FindFilenameDecodeL(*mimeHeader, filename, overrideCharset);
+			filenamePtr.Set(filename);
+			CleanupStack::PopAndDestroy(mimeHeader);
+			}
+		}
+	iAttachmentNameList->AppendL(filenamePtr);
+	}
+CImMimeHeader* CImEmailMessage::FindAttachmentMimeHeaderL()
+	{
+	TMsvId     originalId = iClientEntry.EntryId();
+	CMsvStore* store      = NULL;
+	// If the current entry in the message hierarchy has a store, look for the
+	// mime header there.
+	if (iClientEntry.HasStoreL())
+		{
+		store = iClientEntry.ReadStoreL();
+		CleanupStack::PushL(store);
+		if (!store->IsPresentL(KUidMsgFileMimeHeader))
+			{
+			CleanupStack::PopAndDestroy(store);
+			store = NULL;
+			}
+		}
+	if (store == NULL)
+		{
+		// Check the parent entry in the message hierarchy for the mime header
+		// but only if it is the message.
+		iClientEntry.SetEntryL(iClientEntry.Entry().Parent());
+		if (iClientEntry.Entry().iType == KUidMsvMessageEntry &&
+			iClientEntry.HasStoreL())
+			{
+			store = iClientEntry.ReadStoreL();
+			CleanupStack::PushL(store);
+			if(!store->IsPresentL(KUidMsgFileMimeHeader))
+				{
+				CleanupStack::PopAndDestroy(store);
+				store = NULL;
+				}
+			}
+		}
+	CImMimeHeader* mimeHeader = NULL;
+	if (store)
+		{
+		mimeHeader = CImMimeHeader::NewLC();
+		mimeHeader->RestoreL(*store);
+		// found the mime headers,
+		CMsvMimeHeaders* mimeHeaders = ConvertToMsvMimeHeadersL(mimeHeader);
+		CleanupStack::PushL(mimeHeaders);
+		// store the mimeheaders into the previously stored attachment
+		TInt count = iAttachmentManager->AttachmentInfoSelection().Count();
+		if(count)
+			mimeHeaders->StoreL(*(iAttachmentManager->AttachmentInfoSelection()[count-1]));
+		CleanupStack::PopAndDestroy(mimeHeaders);
+		CleanupStack::Pop(mimeHeader);
+		CleanupStack::PopAndDestroy(store);
+		CleanupStack::PushL(mimeHeader);
+		}
+	if (iClientEntry.EntryId() != originalId)
+		iClientEntry.SetEntryL(originalId);
+	if (mimeHeader)
+		CleanupStack::Pop(mimeHeader);
+	return mimeHeader;
+	}
+TInt CImEmailMessage::FindFilename(const CImMimeHeader& aMimeInfo, TPtrC8& aFilename)
+	{
+	_LIT8(KMimeName,"NAME");
+	_LIT8(KMimeNameRFC2231, "NAME*");
+	_LIT8(KMimeFilename, "FILENAME");
+	_LIT8(KMimeFilenameRFC2231, "FILENAME*");
+	// Look in content-type list
+	const CDesC8Array& ctype = aMimeInfo.ContentTypeParams();
+	TInt tuple = 0;
+	while (tuple < ctype.Count())
+		{
+		// Look for "name xxx"
+		if (ctype[tuple].CompareF(KMimeName) == 0)
+			{
+			// Got it: report that we found it
+			aFilename.Set(ctype[tuple + 1]);
+			return (KErrNone);
+			}
+		else if (ctype[tuple].CompareF(KMimeNameRFC2231) == 0)
+			{
+			// Got it: report that we found it
+			aFilename.Set(ctype[tuple + 1]);
+			return(KRFC2231Encoded);
+			}
+		tuple += 2;
+		}
+	// Not found in the content type, try content disposition
+	tuple = 0;
+	const CDesC8Array& cdisp = aMimeInfo.ContentDispositionParams();
+	while (tuple < cdisp.Count())
+		{
+		// Look for "filename xxx"
+		if (cdisp[tuple].CompareF(KMimeFilename) == 0)
+			{
+			// Got it: report that we found it
+			aFilename.Set(cdisp[tuple + 1]);
+			return(KErrNone);
+			}
+		else if (cdisp[tuple].CompareF(KMimeFilenameRFC2231) == 0)
+			{
+			// Got it: report that we found it
+			aFilename.Set(cdisp[tuple + 1]);
+			return (KRFC2231Encoded);
+			}
+		tuple += 2;
+		}
+	// Didn't find it
+	return(KErrNotFound);
+	}
+void CImEmailMessage::FindFilenameDecodeL(
+	const CImMimeHeader& aMimeInfo, TFileName& aFileName, TUint aCharset)
+	{
+	// Create everything needed for a CImConvertHeader.
+	RFs& fileSvrSession = iClientEntry.Session().FileSession();
+	CCnvCharacterSetConverter* characterConverter = CCnvCharacterSetConverter::NewL();
+	CleanupStack::PushL(characterConverter);
+	CImConvertCharconv* charConv = CImConvertCharconv::NewL(*characterConverter, fileSvrSession);
+	CleanupStack::PushL(charConv);
+	CImConvertHeader* headerConverter = CImConvertHeader::NewL(*charConv);
+	CleanupStack::PushL(headerConverter);
+	// Make an attachment name
+	aFileName.Zero();
+	TPtrC8 origFileName;
+	// Look for filename in Content-Type list
+	TInt returnValue = FindFilename(aMimeInfo, origFileName);
+	if (KErrNotFound != returnValue && KRFC2231Encoded != returnValue)
+		{
+		// Run it through the QP decoder
+		HBufC* decoded = HBufC::NewLC(origFileName.Length());
+		TPtr decoded_ptr(decoded->Des());
+		// Set the overriding charset.
+		headerConverter->SetOverrideCharset(aCharset);
+		/* if it starts =? then assume its RFC2047 encoding -
+		 * otherwise assume its plain text encoded in the system
+		 * charset and decode directly */
+		if (origFileName.Length() >= 2 && origFileName[0] == KImcvEquals && origFileName[1] == KImcvQuestionMark)
+			headerConverter->DecodeHeaderFieldL(origFileName, decoded_ptr);
+		else
+			{
+			if (charConv->PrepareToConvertToFromOurCharsetL(charConv->SystemDefaultCharset()))
+				{
+				// Character set conversion
+				TInt unconvertedChars;
+				TInt pos;
+				charConv->ConvertToOurCharsetL(origFileName, decoded_ptr, unconvertedChars, pos);
+				}
+			else
+				{
+				// Charset not available, don't decode.
+				decoded_ptr.Copy(origFileName);
+				}
+			}
+		aFileName.Copy(decoded_ptr);
+		CleanupStack::PopAndDestroy(); // decoded
+		}
+	CleanupStack::PopAndDestroy(3, characterConverter);
+	}
+TBool CImEmailMessage::HandleDifferentFolderTypesL()
+	{
+	/* This bit of code looks at the folder type and finds out how many children there are
+	 and depending on the type of the reqest (attachments/bodytext etc..) it selects only
+	those type of children and ignores the others.  This avoids going through the whole tree. */
+	TImEmailFolderType folderType=iEntry.MessageFolderType();
+	if(iIsAMHTMLmessage == EFalse && folderType==EFolderTypeRelated)
+		folderType=EFolderTypeMixed;
+	switch (folderType)
+		{
+	case EFolderTypeUnknown:
+	case EFolderTypeMixed:
+	case EFolderTypeParallel:
+	case EFolderTypeDigest:
+	case EFolderTypeRFC822:
+	case EFolderTypePartial:
+	case EFolderTypeDirectory:
+	case EFolderTypeExternal:
+		return ETrue;
+	case EFolderTypeRelated:  //doesn't apply for get- txt,attch,msgdigest
+		if (iState == EAttachmentsForThisMsg)
+			{
+			GetAttachmentsForRelatedFolderL();
+			return EFalse;
+			}
+		else if (iState==EAttachmentsForMsgDigest || iState==EMsgDigestEntries)
+			{
+			return EFalse;
+			}
+		if (iState==ETextForThisMsg || iState==ETextForThisMsgGetCharacterSet || iState==ETextForMsgDigest
+			|| iState == ETextEntryIdForThisMsg || iState == ETextEntryIdMsgDigest)
+			{
+			GetTextForRelatedFolderL();
+			return EFalse;
+			}
+		return ETrue;
+	case EFolderTypeAlternative: // only applies for get text, get body text character set.
+		if (iState==EAttachmentsForThisMsg || iState==EAttachmentsForMsgDigest)
+			{
+			return ETrue;
+			}
+		if (iState==ETextForThisMsg || iState==ETextForThisMsgGetCharacterSet || iState==ETextForMsgDigest
+			|| iState == ETextEntryIdForThisMsg || iState == ETextEntryIdMsgDigest)
+			{
+			GetTextForAlternateFolderL();
+			}
+		return EFalse;
+		}
+	return ETrue;
+	}
+void CImEmailMessage::GetTextForAlternateFolderL()
+	{
+	iClientEntry.SetSortTypeL(TMsvSelectionOrdering(KMsvNoGrouping,EMsvSortByNone,ETrue));
+	TInt count = iClientEntry.Count();
+	TInt typeindex=-1;  //for alternate we need the last id.
+	while (count--)
+		{
+		if (iClientEntry[count].iType.iUid==KUidMsvEmailTextEntryValue)  //ignore the rest of the types.  The last text entry is the best one.
+			{
+			typeindex=count;
+			break;
+			}
+		}
+	if (typeindex >-1) //means it found a txt entry
+		{
+		TKeyArrayFix uidKey(0,ECmpTUint32);
+		iCompleteSel->InsertIsqL(iClientEntry[typeindex].Id(),uidKey);
+		}
+	}
+void CImEmailMessage::GetTextForRelatedFolderL()
+	{
+	iClientEntry.SetSortTypeL(TMsvSelectionOrdering(KMsvNoGrouping,EMsvSortByNone,ETrue));
+	CMsvEntrySelection* sel=iClientEntry.ChildrenL();
+	CleanupStack::PushL(sel);
+	TInt count=sel->Count();
+	TMsvEmailEntry entry;
+	TKeyArrayFix uidKey(0,ECmpTUint32);
+	for (TInt i=0; i<count; i++)
+		{
+		entry=iClientEntry.ChildDataL((*sel)[i]);
+		if ((entry.iType.iUid==KUidMsvFolderEntryValue) || ((iState==ETextForMsgDigest || iState == ETextEntryIdMsgDigest)
+		&& (entry.iType.iUid==KUidMsvMessageEntryValue)))
+			{
+			iCompleteSel->InsertIsqL((*sel)[i],uidKey);
+			};
+		}
+	CleanupStack::PopAndDestroy(); //sel
+	}
+void CImEmailMessage::GetAttachmentsForRelatedFolderL()
+	{
+	// This fixes a defect where forwarding an inline attachment failed. Before this
+	// fix, no attachments under multipart related were forwarded.
+	// This routine will only forward attachments taht are directly under the multipart
+	// related folder.
+	TKeyArrayFix uidKey(0,ECmpTUint32);
+	iClientEntry.SetSortTypeL(TMsvSelectionOrdering(KMsvNoGrouping,EMsvSortByNone,ETrue));
+	for (TInt entry(0); entry < iClientEntry.Count(); entry++)
+		{
+		if (iClientEntry[entry].iType.iUid == KUidMsvAttachmentEntryValue)
+			{
+			iCompleteSel->InsertIsqL(iClientEntry[entry].Id(), uidKey);
+			}
+		}
+	}
+TBool CImEmailMessage::GetBodyTextCharacterSetL()
+	{
+	// Open body text entry store for reading.
+	CMsvStore* store = iClientEntry.ReadStoreL();
+	CleanupStack::PushL(store);
+	// check the body text entry store available if not return EFalse
+	if(!store->HasBodyTextL())
+		{
+		CleanupStack::PopAndDestroy(store); // store.
+		return EFalse;
+		}
+	// Test if the old rich text body OR 16 bit plain body text is present. Return immediately if so,
+	// We are looking for the new 8 bit body text format which has character set
+	// information stored with it.
+	if (store->IsPresentL(KMsvEntryRichTextBody) || store->IsPresentL(KMsvPlainBodyText16))
+		{
+		CleanupStack::PopAndDestroy(store);
+		return EFalse;
+		}
+	// Check if body text is stored as 8 bit body text format
+	if(store->IsPresentL(KMsv8BitEncodedBodyData))
+		{
+		// The body text entry must be the new 8 bit format.
+		CMsvBodyText* bodyText = CMsvBodyText::NewLC();
+		// If there is no body text for this message RestoreL will leave
+		// In this case we will change that into returning EFalse so any
+		// attachments will display properly
+		TRAPD(err, bodyText->RestoreL(*store));
+		if (err == KErrNotFound)
+			{
+			CleanupStack::PopAndDestroy(2, store); // bodyText, store.
+			return EFalse;
+			}
+		iCharacterSetId = bodyText->CharacterSet();
+		if (!iCharacterSetId)
+			{
+			iCharacterSetId = bodyText->DefaultCharacterSet();
+			}
+		CleanupStack::PopAndDestroy(bodyText);
+		}
+	else // Body text is stored as 8 bit plain text.
+		{
+		CMsvPlainBodyText* plainBodyText = store->InitialisePlainBodyTextForReadL(KMaxChunkLength);
+		CleanupStack::PushL(plainBodyText);
+		iCharacterSetId = plainBodyText->CharacterSet();
+		if(!iCharacterSetId)
+			{
+			iCharacterSetId = plainBodyText->DefaultCharacterSet();
+			}
+		CleanupStack::PopAndDestroy(plainBodyText);
+		}
+	CleanupStack::PopAndDestroy(store);
+	return ETrue;
+	}
+/**
+Returns the character set id of the email message entry if it exists.  This method assumes that the
+context is set to the top level message entry.
+*/
+TUint CImEmailMessage::GetOverrideCharacterSetL()
+	{
+	TUint characterSetId = 0;
+	if (iClientEntry.HasStoreL())
+		{
+		CMsvStore* store  = iClientEntry.ReadStoreL();
+		CleanupStack::PushL(store);
+		if (store->IsPresentL(KMessageCharSetStreamUid))
+			{
+			RMsvReadStream in;
+			in.OpenLC(*store, KMessageCharSetStreamUid);
+			in.ReadUint8L(); // Version.
+			characterSetId = in.ReadUint32L();
+			in.Close();
+			CleanupStack::PopAndDestroy(&in);
+			}
+		CleanupStack::PopAndDestroy(store);
+		}
+	return characterSetId;
+	}
+TMsvEntry CImEmailMessage::FindIdEntryL(TMsvId aMessageId)
+	{
+	TMsvId service;
+	TMsvEntry returnEntry;
+	iClientEntry.Session().GetEntry(aMessageId, service, returnEntry);
+	return returnEntry;
+	}
+EXPORT_C MMsvAttachmentManager& CImEmailMessage::AttachmentManager() const
+	{
+	return *iAttachmentManager;
+	}
+void CImEmailMessage::CheckEntryAndResetStoreMessageL(TMsvId aMessageId)
+	{
+	TMsvEntry entry = FindIdEntryL(aMessageId);
+	__ASSERT_DEBUG(entry.iType==KUidMsvMessageEntry, gPanic(EEntryIsNotMessage));
+	// reset the entry with which CImEmailMessage was created
+	iClientEntry.SetEntryL(iEmailEntryId);
+	delete iStoreMessagePart;
+	iStoreMessagePart = NULL;
+	}
+void CImEmailMessage::CheckEntryAndResetRemoveMessageL(TMsvId aMessageId)
+	{
+	TMsvEntry entry = FindIdEntryL(aMessageId);
+	__ASSERT_DEBUG(entry.iType==KUidMsvMessageEntry, gPanic(EEntryIsNotMessage));
+	// reset the entry with which CImEmailMessage was created
+	iClientEntry.SetEntryL(iEmailEntryId);
+	delete iRemoveMessagePart;
+	iRemoveMessagePart = NULL;
+	}
+void CImEmailMessage::DoSetActive(TRequestStatus& aStatus)
+	{
+	Queue(aStatus);
+	SetActive();
+	}
+void CImEmailMessage::AddAttachmentL(const TDesC& aFilePath, CMsvAttachment* aAttachmentInfo, TRequestStatus& aStatus)
+	{
+	// get the message id
+	TMsvId messageId = iClientEntry.EntryId();
+	CheckEntryAndResetStoreMessageL(messageId);
+	iStoreMessagePart = CImStoreMessagePart::AddAttachmentL(messageId,aFilePath,iClientEntry, aAttachmentInfo,iStatus );
+	iState = EStoreMessagePart;
+	iAttachmentState = EAddAttachment;
+	DoSetActive(aStatus);
+	}
+void CImEmailMessage::AddAttachmentL(RFile& aFile, CMsvAttachment* aAttachmentInfo, TRequestStatus& aStatus)
+	{
+	// get the message id
+	TMsvId messageId = iClientEntry.EntryId();
+	CheckEntryAndResetStoreMessageL(messageId);
+	iStoreMessagePart = CImStoreMessagePart::AddAttachmentL(messageId,aFile,iClientEntry, aAttachmentInfo, iStatus);
+	iState = EStoreMessagePart;
+	iAttachmentState = EAddAttachment;
+	DoSetActive(aStatus);
+	}
+void CImEmailMessage::AddLinkedAttachmentL(const TDesC& aFilePath, CMsvAttachment* aAttachmentInfo,TRequestStatus& aStatus)
+	{
+	// get the message id
+	TMsvId messageId = iClientEntry.EntryId();
+	CheckEntryAndResetStoreMessageL(messageId);
+	iStoreMessagePart = CImStoreMessagePart::AddLinkedAttachmentL(messageId,aFilePath,iClientEntry, aAttachmentInfo,iStatus);
+	iState = EStoreMessagePart;
+	iAttachmentState = EAddAttachment;
+	DoSetActive(aStatus);
+	}
+void CImEmailMessage::AddEntryAsAttachmentL(TMsvId aAttachmentEntryId, CMsvAttachment* aAttachmentInfo,TRequestStatus& aStatus)
+	{
+	// get the message id
+	TMsvId messageId = iClientEntry.EntryId();
+	CheckEntryAndResetStoreMessageL(messageId);
+	iStoreMessagePart = CImStoreMessagePart::AddEntryAsAttachmentL(messageId,aAttachmentEntryId,iClientEntry,aAttachmentInfo,iStatus);
+	iState = EStoreMessagePart;
+	iAttachmentState = EAddAttachment;
+	DoSetActive(aStatus);
+	}
+void CImEmailMessage::CreateAttachmentL(const TDesC& aFileName, RFile& aAttachmentFile, CMsvAttachment* aAttachmentInfo, TRequestStatus& aStatus)
+	{
+	// get the message id
+	TMsvId messageId = iClientEntry.EntryId();
+	CheckEntryAndResetStoreMessageL(messageId);
+	iStoreMessagePart = CImStoreMessagePart::CreateAttachmentL(messageId,aFileName,aAttachmentFile,iClientEntry, aAttachmentInfo,iStatus);
+	iState = EStoreMessagePart;
+	iAttachmentState = ECreateAttachment;
+	DoSetActive(aStatus);
+	}
+/**
+Returns a list of attachment information pointers (CMsvAttachment)
+populated by a call to GetAttachmentsListL().
+@pre
+The attachment information list must first be populated by calling GetAttachmentsListL().
+@return
+An array of attachment information objects (CMsvAttachment) representing the attachments
+contained within a particular message specified in the call to GetAttachmentsListL().
+*/
+const RPointerArray<CMsvAttachment>& CImEmailMessage::AttachmentInfoSelection() const
+	{
+	return iAttachmentManager->AttachmentInfoSelection();
+	}
+void CImEmailMessage::RemoveAttachmentL(TMsvAttachmentId aAttachmentId,TRequestStatus& aStatus)
+	{
+	// get the message id
+	TMsvId messageId = iClientEntry.EntryId();
+	CheckEntryAndResetRemoveMessageL(messageId);
+	iRemoveMessagePart = CImRemoveMessagePart::DeleteAttachmentL(iStatus, iClientEntry, messageId, aAttachmentId);
+	iState = ERemoveMessagePart;
+	iAttachmentState = EDeleteAttachment;
+	DoSetActive(aStatus);
+	}
+void CImEmailMessage::RemoveAttachedMessageL(TMsvAttachmentId aAttachmentId,TRequestStatus& aStatus)
+	{
+	// get the message id
+	TMsvId messageId = iClientEntry.EntryId();
+	CheckEntryAndResetRemoveMessageL(messageId);
+	iRemoveMessagePart = CImRemoveMessagePart::DeleteAttachmentL(iStatus, iClientEntry, messageId, aAttachmentId);
+	iState = ERemoveMessagePart;
+	iAttachmentState = EDeleteAttachment;
+	DoSetActive(aStatus);
+	}
+CMsvMimeHeaders* CImEmailMessage::ConvertToMsvMimeHeadersL(CImMimeHeader* aMimeHeader)
+	{
+	CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();
+	CleanupStack::PushL(mimeHeaders);
+	mimeHeaders->SetContentDescriptionL(aMimeHeader->ContentDescription());
+	mimeHeaders->SetContentBaseL(aMimeHeader->ContentBase());
+	mimeHeaders->SetContentLocationL(aMimeHeader->ContentLocation());
+	mimeHeaders->SetContentIdL(aMimeHeader->ContentID());
+	mimeHeaders->SetContentTypeL(aMimeHeader->ContentType());
+	mimeHeaders->SetContentDispositionL(aMimeHeader->ContentDisposition());
+	mimeHeaders->SetMimeCharset(aMimeHeader->MimeCharset());
+	mimeHeaders->SetRelativePathL(aMimeHeader->RelativePath());
+	mimeHeaders->SetContentSubTypeL(aMimeHeader->ContentSubType());
+	mimeHeaders->SetRelativePathL(aMimeHeader->RelativePath());
+	CleanupStack::Pop(mimeHeaders);
+	return mimeHeaders;
+	}
+CImMimeHeader* CImEmailMessage::ConvertToImMimeHeadersL(CMsvMimeHeaders* aMimeHeaders)
+	{
+	CImMimeHeader* mimeHeader = CImMimeHeader::NewL();
+	CleanupStack::PushL(mimeHeader);
+	mimeHeader->SetContentDescriptionL(aMimeHeaders->ContentDescription());
+	mimeHeader->SetContentBaseL(aMimeHeaders->ContentBase());
+	mimeHeader->SetContentLocationL(aMimeHeaders->ContentLocation());
+	mimeHeader->SetContentIDL(aMimeHeaders->ContentId());
+	mimeHeader->SetContentTypeL(aMimeHeaders->ContentType());
+	mimeHeader->SetContentDispositionL(aMimeHeaders->ContentDisposition());
+	mimeHeader->SetMimeCharset(aMimeHeaders->MimeCharset());
+	mimeHeader->SetRelativePathL(aMimeHeaders->RelativePath());
+	mimeHeader->SetContentSubTypeL(aMimeHeaders->ContentSubType());
+	mimeHeader->SetRelativePathL(aMimeHeaders->RelativePath());
+	CleanupStack::Pop(mimeHeader);
+	return mimeHeader;
+	}
+void CImEmailMessage::AppendEntryAttachmentInfoL()
+	{
+	CMsvStore* store = iClientEntry.ReadStoreL();
+	CleanupStack::PushL(store);
+	MMsvAttachmentManager& attachmentMgr = store->AttachmentManagerL();
+	// Modified to handle multiple attachments belonging to a single attachment entry
+	for(TInt i=0;i<attachmentMgr.AttachmentCount();i++)
+		{
+		CMsvAttachment* attachment = attachmentMgr.GetAttachmentInfoL(i);
+		CleanupStack::PushL(attachment);
+		attachment->SetSize(iEntry.iSize);
+		attachment->SetComplete(iEntry.Complete());
+		// For compatibility keep entry [0] as the TMsvId of the owning attachment entry
+		if(i == 0)
+			{
+			attachment->SetId(iClientEntry.EntryId());
+			}
+		else
+			{
+			// Store the index and the owning attachment entry's TMsvId
+			attachment->SetIntAttributeL(KUidMsvEmailAttachmentEntryIndex,i);
+			attachment->SetIntAttributeL(KUidMsvEmailAttachmentEntryId,iClientEntry.EntryId());
+			attachment->SetId(iAttachmentManager->UniqueAttachmentId());
+			}
+		// Add to the per-message list of CMsvAttachments
+		User::LeaveIfError(iAttachmentManager->AttachmentInfoSelection().Append(attachment));
+		CleanupStack::Pop(attachment);
+		}
+	CleanupStack::PopAndDestroy(store);
+	}
+TMsvId CImEmailMessage::EmailEntryId()
+	{
+	return iClientEntry.EntryId();
+	}
+/**
+This returns a object of CImPlainBodyText.This needs to be called when bodytext
+needs to be restored in chunks for Read operation.
+@param aMessageId	The Message Id for which to get plain body text part.
+@param aEntryType   The TImEmailEntryType for this message.
+@return CMsvPlainBodyText
+*/
+EXPORT_C CImPlainBodyText* CImEmailMessage::OpenPlainBodyTextForReadL(TImEmailEntryType aEntryType, TInt aChunkLength)
+	{
+	CImPlainBodyText* plainBodyText = CImPlainBodyText::NewL(*this, iClientEntry, aEntryType, aChunkLength, EFalse);
+	return plainBodyText;
+	}
+/**
+This returns a object of CImPlainBodyText.This needs to be called when bodytext
+needs to be created in chunks.
+@param aMessageId	  The id of the message whose bodytext needs to be edited.
+@return CImPlainBodyText
+*/
+EXPORT_C CImPlainBodyText* CImEmailMessage::OpenPlainBodyTextForWriteL()
+	{
+	CImPlainBodyText* plainBodyText = CImPlainBodyText::NewL(*this, iClientEntry, CImEmailMessage::EThisMessageOnly, KMaxChunkLength, ETrue);
+	return plainBodyText;
+	}
+//
+// CImRemoveMessagePart
+//
+CImRemoveMessagePart* CImRemoveMessagePart::DeleteAttachmentL(TRequestStatus &aStatus, CMsvEntry& aMsvEntry, TMsvId aMessageId, TMsvId aAttachmentId)
+	{
+	CImRemoveMessagePart* self = new(ELeave) CImRemoveMessagePart(aStatus, aMsvEntry, aMessageId);
+	CleanupStack::PushL(self);
+	self->ConstructL(aAttachmentId);
+	CleanupStack::Pop(); //self
+	return self;
+	}
+CImRemoveMessagePart* CImRemoveMessagePart::DeleteAttachedMessageL(TRequestStatus &aStatus, CMsvEntry& aMsvEntry, TMsvId aMessageId, TMsvId aAttachedMessageId)
+	{
+	// this does exactly the same as for DeleteAttachmentL() but this function is added to seperate deleting attachments/attached messages
+	CImRemoveMessagePart* self = new(ELeave) CImRemoveMessagePart(aStatus, aMsvEntry, aMessageId);
+	CleanupStack::PushL(self);
+	self->ConstructL(aAttachedMessageId);
+	CleanupStack::Pop();
+	return self;
+	}
+CImRemoveMessagePart::~CImRemoveMessagePart()
+	{
+	Cancel();
+	delete iMsvOperation;
+	delete iMessageEntrySelection;
+	delete iEmailMessage;
+	}
+const TDesC8& CImRemoveMessagePart::FinalProgress()
+	{
+	__ASSERT_ALWAYS(!IsActive(), gPanic(EMiutActiveInFinalProgress));
+	const TDesC8* progress = &KNullDesC8();
+	TRAPD(leave, progress = &ProgressL());
+	__ASSERT_ALWAYS(leave == KErrNone, gPanic(EImcmFinalProgressFailed));
+	return *progress;
+	}
+const TDesC8& CImRemoveMessagePart::ProgressL()
+	{
+	if (iState==EFinished)
+		iDataMember() = iMessageId;
+	return iDataMember;
+	}
+void CImRemoveMessagePart::DoCancel()
+	{
+	if (iMsvOperation)
+		iMsvOperation->Cancel();
+	if (iEmailMessage)
+		iEmailMessage->Cancel();
+	Recover();
+	TRequestStatus* st = &iObserverRequestStatus;
+	User::RequestComplete(st, KErrCancel);
+	}
+void CImRemoveMessagePart::SelectAndChangeToNextStateL()
+	{
+	SelectNextStateL();
+	ChangeStateL();
+	}
+void CImRemoveMessagePart::RunL()
+	{
+	if (iStatus.Int() != KErrNone)
+		{
+		ErrorRecovery(iStatus.Int());
+		return;
+		}
+	if ((iState == EMoveOtherEntryToParentOfFolder) ||
+		(iState == EDeleteAttachmentEntry) ||
+		(iState == EDeleteFolderEntry) ||
+		(iState == ECompleteRemoveMessagePart))
+		{
+		TInt sysProgressError = McliUtils::GetProgressErrorL(*iMsvOperation);
+		if (sysProgressError != KErrNone)
+			{
+			ErrorRecovery(sysProgressError);
+			return;
+			}
+		}
+	if (iState != EFinished)
+		{
+		TRAPD(error, SelectAndChangeToNextStateL());
+		if (error)
+			ErrorRecovery(error);
+		else if (iState != EFinished)
+			SetActive();
+		}
+	}
+CImRemoveMessagePart::CImRemoveMessagePart(TRequestStatus& aStatus, CMsvEntry& aMsvEntry, TMsvId aMessageId)
+	: CMsvOperation(aMsvEntry.Session(), EPriorityStandard, aStatus),
+	  iMsvEntry(aMsvEntry),
+	  iMessageId(aMessageId)
+	{
+	}
+void CImRemoveMessagePart::ConstructL(TMsvId aAttachmentId)
+	{
+	iDataMember = KMsvNullIndexEntryId;
+	iAttachmentId = aAttachmentId;
+	iFolderToDeleteId = KMsvNullIndexEntryId;
+	iEntryToMoveId = KMsvNullIndexEntryId;
+	iEmailMessage = CImEmailMessage::NewL(iMsvEntry);
+	CActiveScheduler::Add(this);
+	TMsvId serviceId = KMsvNullIndexEntryId;
+	TMsvEmailEntry attachmentEntry;
+	iMsvEntry.Session().GetEntry(iAttachmentId, serviceId, attachmentEntry);
+	iAttachmentSize = attachmentEntry.iSize;
+	iState = ECheckAttachmentParentType;
+	ChangeStateL();
+	iObserverRequestStatus = KRequestPending;
+	SetActive();
+	}
+void CImRemoveMessagePart::ErrorRecovery(TInt error)
+	{
+	// if there is an error then leave message in a 'good' state
+	Recover();
+	// complete the observer with error
+	TRequestStatus* status=&iObserverRequestStatus;
+	User::RequestComplete(status,error);
+	}
+void CImRemoveMessagePart::SelectNextStateL()
+	{
+	switch (iState)
+		{
+	// do move and then the delete because if the move fails, the message
+	// will still be in a good state
+	case ECheckAttachmentParentType:
+		{
+		// set entry to parent just in case GetAttachmentsListL changes context
+		TMsvId serviceId; // temp
+		TMsvEmailEntry attachmentEntry;
+		iMsvEntry.Session().GetEntry(iAttachmentId, serviceId, attachmentEntry);
+		iMsvEntry.SetEntryL(attachmentEntry.Parent());
+		iState = EDeleteAttachmentEntry;
+		}
+		break;
+	case EMoveOtherEntryToParentOfFolder:
+		iState = EDeleteFolderEntry;
+		break;
+	case EDeleteAttachmentEntry:
+		if (iFolderToDeleteId)
+			iState = EMoveOtherEntryToParentOfFolder;
+		else
+			iState = ECompleteRemoveMessagePart;
+		break;
+	case EDeleteFolderEntry:
+		iState = ECompleteRemoveMessagePart;
+		break;
+	case ECompleteRemoveMessagePart:
+		iState = EFinished;
+		break;
+	default:
+		User::LeaveIfError(KErrNotSupported);
+		}
+	}
+void CImRemoveMessagePart::ChangeStateL()
+	{
+	switch (iState)
+		{
+	case ECheckAttachmentParentType:
+		CheckAttachmentParentTypeL();
+		break;
+	case EMoveOtherEntryToParentOfFolder:
+		MoveOtherEntryToParentOfFolderL();
+		break;
+	case EDeleteAttachmentEntry:
+		DeleteAttachmentEntryL();
+		break;
+	case EDeleteFolderEntry:
+		DeleteFolderEntryL();
+		break;
+	case ECompleteRemoveMessagePart:
+		CompleteRemoveMessagePartL();
+		break;
+	case EFinished:
+		{
+		TRequestStatus* status=&iObserverRequestStatus;
+		User::RequestComplete(status,KErrNone);
+		}
+		}
+	}
+void CImRemoveMessagePart::RequestComplete(TInt aError)
+	{
+	iStatus = KRequestPending;
+	TRequestStatus* status=&iStatus;
+	iStatus=KRequestPending;
+	User::RequestComplete(status,aError);
+	}
+void CImRemoveMessagePart::Recover()
+	{
+	switch (iState)
+		{
+	case EDeleteFolderEntry:
+	case EDeleteAttachmentEntry:
+		// delete folder if one exists else delete attachment
+		if (iFolderToDeleteId)
+			iMsvEntry.Session().RemoveEntry(iFolderToDeleteId);
+		else
+			iMsvEntry.Session().RemoveEntry(iAttachmentId);
+		break;
+	case ECompleteRemoveMessagePart: // not fatal - details might be incorrect but delete already done
+	// for other states - original message not changed:
+	case EMoveOtherEntryToParentOfFolder:
+	case ECheckAttachmentParentType:
+	case EFinished:	// operation completed anyway
+		break;
+		}
+	}
+void CImRemoveMessagePart::CheckAttachmentParentTypeL()
+	{
+	TMsvId serviceId; // temp
+	TMsvEmailEntry attachmentEntry;
+	iMsvEntry.Session().GetEntry(iAttachmentId, serviceId, attachmentEntry);
+	iMsvEntry.SetEntryL(attachmentEntry.Parent());
+	// get children of attachments parent
+	iMessageEntrySelection = iMsvEntry.ChildrenL();
+	TMsvEmailEntry parentEntry = iMsvEntry.Entry();
+	if (parentEntry.iType == KUidMsvFolderEntry)
+		{
+		// if there are 2 or less children, the other children need to be moved and then the folder deleted
+		if (iMessageEntrySelection->Count() <= 2)
+			iFolderToDeleteId = iMsvEntry.EntryId();
+		}
+	// if there are no other attachments then unset attachment flag in message
+	iEmailMessage->GetAttachmentsListL(iStatus, iMessageId, CImEmailMessage::EAllAttachments,CImEmailMessage::EThisMessageOnly);
+	}
+void CImRemoveMessagePart::MoveOtherEntryToParentOfFolderL()
+	{
+	// context on parent of attachment
+	// move entry to folder's parent
+	TInt i = iMessageEntrySelection->Count();
+	while (i--)
+		{
+		if ((*iMessageEntrySelection)[i] != iAttachmentId)
+			iEntryToMoveId = (*iMessageEntrySelection)[i];
+		}
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	iMsvOperation = iMsvEntry.MoveL(iEntryToMoveId, iMsvEntry.Entry().Parent(), iStatus);
+	}
+void CImRemoveMessagePart::DeleteAttachmentEntryL()
+	{
+	// context on parent of attachment
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	iMsvOperation = iMsvEntry.DeleteL(iAttachmentId, iStatus);
+	}
+void CImRemoveMessagePart::DeleteFolderEntryL()
+	{
+	// context on parent of attachment - i.e. folder
+	// move context to parent of folder before deleting folder
+	iMsvEntry.SetEntryL(iMsvEntry.Entry().Parent());
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	iMsvOperation = iMsvEntry.DeleteL(iFolderToDeleteId, iStatus);
+	}
+void CImRemoveMessagePart::CompleteRemoveMessagePartL()
+	{
+	iMsvEntry.SetEntryL(iMessageId);
+	TMsvEntry entry(iMsvEntry.Entry());
+	TInt count = iEmailMessage->AttachmentManager().AttachmentCount();
+	if (count)
+		{
+		entry.SetAttachment((count-1)); // minus one since we have removed attachment
+		}
+	// update the size
+	entry.iSize -= iAttachmentSize;
+	CMsvEntrySelection* selection = iMsvEntry.ChildrenWithTypeL(KUidMsvFolderEntry);
+	CleanupStack::PushL(selection);
+	CMsvStore* store = iMsvEntry.EditStoreL();
+	CleanupStack::PushL(store);
+	if (selection->Count()) // folder exist
+		{
+		TMsvEmailEntry childEntry = iMsvEntry.ChildDataL((*selection)[0]);
+		CImMimeHeader* mimeHeader = CImMimeHeader::NewLC();
+		mimeHeader->RestoreL(*store);
+		switch (childEntry.MessageFolderType())
+			{
+		case EFolderTypeAlternative:
+			mimeHeader->SetContentSubTypeL(KMimeAlternative);
+			break;
+		case EFolderTypeMixed:
+			mimeHeader->SetContentSubTypeL(KMimeMixed);
+			break;
+		case EFolderTypeRelated:
+			mimeHeader->SetContentSubTypeL(KMimeRelated);
+			break;
+		default:
+			User::Leave(KErrNotSupported);
+			}
+		mimeHeader->StoreL(*store);
+		store->CommitL();
+		CleanupStack::PopAndDestroy(); // mimeHeader
+		}
+	else if (store->IsPresentL(KUidMsgFileMimeHeader))
+		{
+		// if the child of the message is not a folder then the MimeHeader must be deleted
+		store->RemoveL(KUidMsgFileMimeHeader);
+		store->CommitL();
+		}
+	CleanupStack::PopAndDestroy(2); // selection, store
+	delete iMsvOperation;
+	iMsvOperation=NULL;
+	iMsvOperation=iMsvEntry.ChangeL(entry, iStatus);
+	}
+TMsvId CImRemoveMessagePart::RemovedAttachmentId()
+	{
+	return iAttachmentId;
+	}
+//
+// CImStoreMessagePart
+//
+CImStoreMessagePart* CImStoreMessagePart::AddAttachmentL(TMsvId aMessageId,const TDesC& aFilePath, CMsvEntry& aMsvEntry,CMsvAttachment* aAttachmentInfo,TRequestStatus& aStatus )
+	{
+	CImStoreMessagePart* self = new(ELeave) CImStoreMessagePart(aStatus, aMsvEntry,aMessageId);
+	CleanupStack::PushL(self);
+	self->ConstructL(aFilePath);
+	self->ConstructAttachmentInfo(aAttachmentInfo,EAddAttachment);
+	CleanupStack::Pop(self);
+	return self;
+	}
+CImStoreMessagePart* CImStoreMessagePart::AddEntryAsAttachmentL(TMsvId aMessageId,TMsvId aAttachmentMessageId, CMsvEntry& aMsvEntry, CMsvAttachment* aAttachmentInfo, TRequestStatus& aStatus)
+	{
+	CImStoreMessagePart* self = new(ELeave) CImStoreMessagePart(aStatus, aMsvEntry, aMessageId);
+	CleanupStack::PushL(self);
+	self->ConstructL(aAttachmentMessageId);
+	self->ConstructAttachmentInfo(aAttachmentInfo,EAddEntryAsAttachment);
+	CleanupStack::Pop(self);
+	return self;
+	}
+CImStoreMessagePart* CImStoreMessagePart::AddAttachmentL(TMsvId aMessageId, RFile& aFile, CMsvEntry& aMsvEntry, CMsvAttachment* aAttachmentInfo, TRequestStatus& aStatus)
+	{
+	CImStoreMessagePart* self = new(ELeave) CImStoreMessagePart(aStatus, aMsvEntry,aMessageId);
+	CleanupStack::PushL(self);
+	self->ConstructL(aFile);
+	self->ConstructAttachmentInfo(aAttachmentInfo,EAddAttachmentUsingFileHandle);
+	CleanupStack::Pop(self);
+	return self;
+	}
+CImStoreMessagePart* CImStoreMessagePart::CreateAttachmentL(TMsvId aMessageId,const TDesC& aFileName, RFile& aAttachmentFile,CMsvEntry& aMsvEntry, CMsvAttachment* aAttachmentInfo, TRequestStatus& aStatus)
+	{
+	CImStoreMessagePart* self = new(ELeave) CImStoreMessagePart(aStatus, aMsvEntry,aMessageId);
+	CleanupStack::PushL(self);
+	self->ConstructL(aAttachmentFile,aFileName);
+	self->ConstructAttachmentInfo(aAttachmentInfo,ECreateAttachment);
+	CleanupStack::Pop(self);
+	return self;
+	}
+CImStoreMessagePart* CImStoreMessagePart::AddLinkedAttachmentL(TMsvId aMessageId,const TDesC& aFilePath, CMsvEntry& aMsvEntry,CMsvAttachment* aAttachmentInfo,TRequestStatus& aStatus )
+	{
+	CImStoreMessagePart* self = new(ELeave) CImStoreMessagePart(aStatus, aMsvEntry,aMessageId);
+	CleanupStack::PushL(self);
+	self->ConstructL(aFilePath);
+	self->ConstructAttachmentInfo(aAttachmentInfo,EAddLinkedAttachment);
+	CleanupStack::Pop(self);
+	return self;
+	}
+CImStoreMessagePart* CImStoreMessagePart::AddRelatedPartL(TRequestStatus &aStatus, CMsvEntry& aMsvEntry, TMsvId aMessageId, const TDesC& aAttachmentFullName, TMsvId aRelatedPartId, const TDesC8& aContentId)
+	{
+	CImStoreMessagePart* self = new(ELeave) CImStoreMessagePart(aStatus, aMsvEntry, aMessageId);
+	CleanupStack::PushL(self);
+	self->ConstructL(aAttachmentFullName, aRelatedPartId, aContentId);
+	CleanupStack::Pop(self);
+	return self;
+	}
+CImStoreMessagePart* CImStoreMessagePart::StoreBodyTextL(TRequestStatus& aStatus, CMsvEntry& aMsvEntry, TMsvId aMessageId, CRichText& aRichText, TBool aUsePlainTextStorage)
+	{
+	CImStoreMessagePart* self = new(ELeave) CImStoreMessagePart(aStatus, aMsvEntry, aMessageId, aUsePlainTextStorage);
+	CleanupStack::PushL(self);
+	self->ConstructL(aRichText);
+	CleanupStack::Pop(self);
+	return self;
+	}
+CImStoreMessagePart* CImStoreMessagePart::StoreBodyTextWithMimeHeaderL(TRequestStatus& aStatus, CMsvEntry& aMsvEntry, TMsvId aMessageId, CRichText& aRichText, const CImMimeHeader& aMimeHeader, TBool aUsePlainTextStorage)
+	{
+	CImStoreMessagePart* self = new(ELeave) CImStoreMessagePart(aStatus, aMsvEntry, aMessageId, aUsePlainTextStorage);
+	CleanupStack::PushL(self);
+	self->ConstructL(aRichText, aMimeHeader);
+	CleanupStack::Pop(self);
+	return self;
+	}
+CImStoreMessagePart* CImStoreMessagePart::StorePlainBodyTextL(TRequestStatus& aStatus, CMsvEntry& aMsvEntry, TMsvId aMessageId, TBool aUsePlainTextStorage)
+	{
+	CImStoreMessagePart* self = new(ELeave) CImStoreMessagePart(aStatus, aMsvEntry, aMessageId, aUsePlainTextStorage);
+	CleanupStack::PushL(self);
+	self->ConstructL(EMessagePartBody);
+	CleanupStack::Pop(self);
+	return self;
+	}
+CImStoreMessagePart* CImStoreMessagePart::StorePlainBodyTextL(TRequestStatus& aStatus, CMsvEntry& aMsvEntry, TMsvId aMessageId,CImMimeHeader& aMimeHeader, TBool aUsePlainTextStorage)
+	{
+	CImStoreMessagePart* self = new(ELeave) CImStoreMessagePart(aStatus, aMsvEntry, aMessageId, aUsePlainTextStorage);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMimeHeader);
+	CleanupStack::Pop(self);
+	return self;
+	}
+CImStoreMessagePart::~CImStoreMessagePart()
+	{
+	Cancel();
+	delete iMsvOperation;
+	delete iFileMan;
+	delete iMessageEntrySelection;
+	delete iAttachmentFullName;
+	delete iContentId;
+	delete iHtmlConverter;
+	delete iParaLayer;
+	delete iCharLayer;
+	delete iEmailMessage;
+	delete iRichText;
+	delete iStore;
+	delete iAttachmentInfo;
+	}
+const TDesC8& CImStoreMessagePart::FinalProgress()
+	{
+	__ASSERT_ALWAYS(!IsActive(), gPanic(EMiutActiveInFinalProgress));
+	const TDesC8* progress = &KNullDesC8();
+	TRAPD(leave, progress = &ProgressL());
+	__ASSERT_ALWAYS(leave == KErrNone, gPanic(EImcmFinalProgressFailed));
+	return *progress;
+	}
+const TDesC8& CImStoreMessagePart::ProgressL()
+	{
+	if (iState==EFinished)
+		{
+		switch(iMessagePart)
+			{
+		case EMessagePartAttachment:
+		case EMessagePartMessageAttachment:
+			iDataMember() = iAttachmentId;
+			break;
+		case EMessagePartBody:
+			iDataMember() = iMessageId;
+			break;
+		default:
+			iDataMember() = KMsvNullIndexEntryId;
+			User::Leave(KErrNotSupported);
+			}
+		}
+	return iDataMember;
+	}
+void CImStoreMessagePart::DoCancel()
+	{
+	if (iMsvOperation)
+		iMsvOperation->Cancel();
+	if (iEmailMessage)
+		iEmailMessage->Cancel();
+	// If we are in a state where we are waiting for the attachment manager to
+	// complete us, then we need to cancel the attachment manager request
+	if ((iState == EStoreAttachment) || (iState == EAddEntryAttachment))
+		{
+		if (iStore != NULL)
+			{
+			MMsvAttachmentManager* attachmentMgr(NULL);
+			TRAPD(err, attachmentMgr = &(iStore->AttachmentManagerL()));
+			if (err == KErrNone)
+				{
+				attachmentMgr->CancelRequest();
+				}
+			}
+		}
+	else
+		{
+		// we are not waiting for the attachment manager to complete us,
+		// so the file handle needs to be closed by us.
+		if((iAttachmentInfo != NULL) && (iAttachmentCreateState == EAddAttachmentUsingFileHandle))
+			{
+			iFile.Close();
+			}
+		}
+	// Use ErrorRecovery routine to cleanup and complete the caller with KErrCancel
+	ErrorRecovery(KErrCancel);
+	}
+void CImStoreMessagePart::SelectAndChangeToNextStateL()
+	{
+	SelectNextStateL();
+	ChangeStateL();
+	}
+void CImStoreMessagePart::RunL()
+	{
+	if (iStatus.Int() != KErrNone)
+		{
+		ErrorRecovery(iStatus.Int());
+		return;
+		}
+	if ((iState == ECreateAttachmentEntry) ||
+		(iState == ECopyOrigMessageToMessage) ||
+		(iState == ECreateMultipartMixedFolderEntry) ||
+		(iState == ECreateMultipartRelatedFolderEntry) ||
+		(iState == ECreateMultipartAlternativeFolderEntry) ||
+		(iState == EMoveOriginalMessageEntryChildrenToNewFolder) ||
+		(iState == ECreateTextEntry) ||
+		(iState == EStoreRichText) ||
+		(iState == ECreateHTMLEntry) ||
+		(iState == ERemoveHTMLEntry && iHtmlId !=KMsvNullIndexEntryId) ||
+		(iState == EMoveTextToAlternativeFolder) ||
+		(iState == ECompleteStoreMessage))
+		{
+		TInt sysProgressError = McliUtils::GetProgressErrorL(*iMsvOperation);
+		if (sysProgressError != KErrNone)
+			{
+			ErrorRecovery(sysProgressError);
+			return;
+			}
+		}
+	if (iState != EFinished)
+		{
+		TRAPD(error, SelectAndChangeToNextStateL());
+		if (error)
+			ErrorRecovery(error);
+		else if (iState != EFinished)
+			SetActive();
+		}
+	}
+CImStoreMessagePart::CImStoreMessagePart(TRequestStatus& aStatus, CMsvEntry& aMsvEntry, TMsvId aMessageId, TBool aUsePlainTextStorage)
+	: CMsvOperation(aMsvEntry.Session(), EPriorityStandard, aStatus),
+	  iMsvEntry(aMsvEntry),
+	  iMessageId(aMessageId),
+	  iUsePlainTextStorage(aUsePlainTextStorage)
+	{
+	}
+void CImStoreMessagePart::OpenAndReadResourceFileL()
+	{
+	RResourceFile resourceFile;
+	OpenResourceFileL(resourceFile, iMsvSession.FileSession());
+	CleanupClosePushL(resourceFile);
+	if (iHtmlConverter)
+		iHtmlConverter->ReadDefaultAttachmentNameL(resourceFile);
+	CleanupStack::PopAndDestroy(); // resourceFile (Close resourceFile)
+	}
+void CImStoreMessagePart::ConstructL()
+	{
+	iFlags = KStoreMessagePartClearFlag;
+	iDataMember = KMsvNullIndexEntryId;
+	iMixFolderId = KMsvNullIndexEntryId;
+	iAltFolderId = KMsvNullIndexEntryId;
+	iAttachmentId = KMsvNullIndexEntryId;
+	iTextId = KMsvNullIndexEntryId;
+	iHtmlId = KMsvNullIndexEntryId;
+	iFileMan = CFileMan::NewL(iMsvEntry.Session().FileSession());
+	iParaLayer = CParaFormatLayer::NewL();
+	iCharLayer = CCharFormatLayer::NewL();
+	iRichText = CRichText::NewL(iParaLayer, iCharLayer);
+	iEmailMessage = CImEmailMessage::NewL(iMsvEntry);
+	CActiveScheduler::Add(this);
+	if (iRelatedPartId != KMsvNullIndexEntryId)
+		iState = EFindMultipartRelatedFolder;
+	else
+		iState = ECheckForSubfolder;
+	ChangeStateL();
+	iObserverRequestStatus = KRequestPending;
+	SetActive();
+	}
+void CImStoreMessagePart::ConstructL(TImMessagePart aMessagePart)
+	{
+	iMessagePart = aMessagePart;
+	ConstructL();
+	}
+void CImStoreMessagePart::ConstructL(const TDesC& aAttachmentFullName)
+	{
+	iAttachmentFullName = aAttachmentFullName.AllocL();
+	iMessagePart = EMessagePartAttachment;
+	ConstructL();
+	}
+void CImStoreMessagePart::ConstructL(TMsvId aAttachmentMessageId)
+	{
+	iAttachmentMessageId = aAttachmentMessageId;
+	iMessagePart = EMessagePartMessageAttachment;
+	ConstructL();
+	}
+void CImStoreMessagePart::ConstructL(const TDesC& aAttachmentFullName, TMsvId aRelatedPartId, const TDesC8& aContentId)
+	{
+	iAttachmentFullName = aAttachmentFullName.AllocL();
+	iRelatedPartId = aRelatedPartId;
+	iMessagePart = EMessagePartAttachment;
+	iContentId = aContentId.AllocL();
+	ConstructL();
+	}
+void CImStoreMessagePart::ConstructL(CRichText& aRichText)
+	{
+	iRichTextToStore=&aRichText;
+	iMessagePart = EMessagePartBody;
+	ConstructL();
+	}
+void CImStoreMessagePart::ConstructL(CRichText& aRichText, const CImMimeHeader& aMimeHeader)
+	{
+	iRichTextToStore=&aRichText;
+	// We don't take ownership of the Mime header, we just 'flag'
+	// its presence:
+	iMimeHeaderOfBodyText=const_cast<CImMimeHeader*>(&aMimeHeader);
+	iMessagePart = EMessagePartBody;
+	ConstructL();
+	}
+void CImStoreMessagePart::ConstructL(CImMimeHeader& aMimeHeader)
+	{
+	// We don't take ownership of the Mime header, we just 'flag'
+	// its presence:
+	iMimeHeaderOfBodyText = &aMimeHeader;
+	iMessagePart = EMessagePartBody;
+	ConstructL();
+	}
+void CImStoreMessagePart::ConstructL(const TDesC& aAttachmentFullName, const TDesC8& aContentId)
+	{
+	iAttachmentFullName = aAttachmentFullName.AllocL();
+	iMessagePart = EMessagePartAttachment;
+	iContentId = aContentId.AllocL();
+	iStore=NULL;
+	ConstructL();
+	}
+void CImStoreMessagePart::ConstructL(RFile& aFile)
+	{
+	iFile = aFile;
+	iFileHandle=&aFile;
+	iMessagePart = EMessagePartAttachment;
+	iIsAddByFileHandle = ETrue;
+	ConstructL();
+	}
+void CImStoreMessagePart::ConstructL(RFile& aFile,const TDesC& aAttachmentName)
+	{
+	iAttachmentFullName = aAttachmentName.AllocL();
+	iFileHandle=&aFile;
+	iMessagePart = EMessagePartAttachment;
+	iIsAddByFileHandle=ETrue;
+	ConstructL();
+	}
+void CImStoreMessagePart::ConstructAttachmentInfo(CMsvAttachment* aAttachmentInfo,TInt aAttachmentCreationState)
+	{
+	iAttachmentInfo = aAttachmentInfo;
+	iAttachmentCreateState = aAttachmentCreationState;
+	}
+void CImStoreMessagePart::ErrorRecovery(TInt error)
+	{
+	iHtmlConverter->ResetStoreWithoutCommit();
+	// Close store if it is currently open for read or edit
+	if (iStore != NULL)
+		{
+		delete iStore;
+		iStore = NULL;
+		}
+	// if there is an error then need to undo any changes
+	Recover();
+	// complete the observer with error
+	TRequestStatus* status=&iObserverRequestStatus;
+	User::RequestComplete(status,error);
+	}
+void CImStoreMessagePart::SelectNextStateL()
+	{
+	switch (iState)
+		{
+	case EFindMultipartRelatedFolder:
+		iState = ECheckForSubfolder;
+		break;
+	case ECheckForSubfolder:
+		// context on Message
+		if (iEmailMessage->Selection().Count())
+			iTextId = iEmailMessage->Selection().At(0);
+		SetTextPartExists(iEmailMessage->Selection().Count());
+		if (iMessagePart == EMessagePartAttachment)
+			{
+			if (iMessageEntrySelection->Count() && (iRelatedPartId == KMsvNullIndexEntryId) && (!MultipartMixedExists()))
+				// one item under message entry as we should have more than one entry under message entry
+				iState = ECreateMultipartMixedFolderEntry;
+			else if (iMessageEntrySelection->Count() && (iRelatedPartId != KMsvNullIndexEntryId) && (!MultipartRelatedExists()))
+				{
+				// we want to add an attachment related to iRelatedPartId
+				if (MultipartMixedExists())
+					iMsvEntry.SetEntryL(iMixFolderId);
+				iState = ECreateMultipartRelatedFolderEntry;
+				}
+			else
+				{
+				// if multipart/related exists then set context to related
+				if (MultipartRelatedExists())
+					iMsvEntry.SetEntryL(iRelFolderId);
+				if (MultipartMixedExists())
+					iMsvEntry.SetEntryL(iMixFolderId);
+				iState = ECreateAttachmentEntry;
+				}
+			}
+		else if (iMessagePart == EMessagePartMessageAttachment)
+			{
+			if (iMessageEntrySelection->Count() && (iRelatedPartId == KMsvNullIndexEntryId) && (!MultipartMixedExists()))
+				// one item under message entry as we should have more than one entry under message entry
+				iState = ECreateMultipartMixedFolderEntry;
+			else
+				iState = ECopyOrigMessageToMessage;
+			}
+		else if (iMessagePart == EMessagePartBody)
+			{
+	        if (HTMLMessage() && iHtmlConverter)
+	            {
+	            if (iTextId != KMsvNullIndexEntryId)
+		            {
+		            if (MultipartAlternativeExists())
+		                {
+		                // Alternative folder exists - continue as normal...
+		                iState = EStoreRichText;
+		                }
+	                else
+						{
+						// This is an HTML message and the text entry already
+						// exists. Need to check that the text entry's parent
+						// is an alternative folder.
+						TMsvId serviceId = KMsvNullIndexEntryId;
+						TMsvEmailEntry entry;
+						// Get text entry...
+						iMsvEntry.Session().GetEntry(iTextId, serviceId, entry);
+						// ...and then its parent
+						iMsvEntry.Session().GetEntry(entry.Parent(), serviceId, entry);
+						if (entry.MessageFolderType() != EFolderTypeAlternative)
+							{
+						   // The situation is that a text entry exist, but there
+	                       // is no alternative folder for. This is probably cos
+// the message was originally plain, but has been changed
+// to be an HTML message. Create the alternative folder
+// under the text entry's parent.
+	                       if (iMsvEntry.EntryId() != entry.Id())
+		                       {
+		                       // Ensure that entry text entry's parent
+		                       iMsvEntry.SetEntryL(entry.Id());
+							   }
+			                  iState = ECreateMultipartAlternativeFolderEntry;
+		                   }
+						else
+						   {
+			              // Alternative folder exists - continue as normal...
+	                      iState = EStoreRichText;
+						   }
+						}
+					}
+				else
+					{
+					// No text entry exists - need to create an alternative folder
+					iState = ECreateMultipartAlternativeFolderEntry;
+					}
+				}
+			else if (iTextId != KMsvNullIndexEntryId)
+				iState = EStoreRichText;
+			else if (iMessageEntrySelection->Count() && (!MultipartMixedExists())) // one item under message entry
+				iState = ECreateMultipartMixedFolderEntry;
+			else
+				{
+				if (MultipartMixedExists())
+					iMsvEntry.SetEntryL(iMixFolderId);
+				iState = ECreateTextEntry;
+				}
+			}
+		break;
+	case ECreateMultipartMixedFolderEntry:
+		{
+		SetMultipartMixedCreated(ETrue);
+		iMixFolderId = McliUtils::GetProgressIdL(*iMsvOperation);
+		iMsvEntry.SetEntryL(iMixFolderId);
+		switch (iMessagePart)
+			{
+		case EMessagePartAttachment:
+		case EMessagePartMessageAttachment:
+			if ((iRelatedPartId != KMsvNullIndexEntryId) && (!MultipartRelatedExists()))
+				iState = ECreateMultipartRelatedFolderEntry;
+			else if (iMessagePart == EMessagePartAttachment)
+				iState = ECreateAttachmentEntry;
+			else if (iMessagePart == EMessagePartMessageAttachment)
+				iState = ECopyOrigMessageToMessage;
+			break;
+		case EMessagePartBody:
+			if (HTMLMessage())
+				iState = ECreateMultipartAlternativeFolderEntry;
+			else
+				iState = ECreateTextEntry;
+			break;
+		default:
+			User::Leave(KErrNotSupported);
+			}
+		}
+		break;
+	case ECreateMultipartRelatedFolderEntry:
+		{
+		SetMultipartRelatedCreated(ETrue);
+		iRelFolderId = McliUtils::GetProgressIdL(*iMsvOperation);
+		iMsvEntry.SetEntryL(iRelFolderId);
+		iState = ECreateAttachmentEntry;
+		}
+		break;
+	case ECreateAttachmentEntry:
+		{
+		SetAttachmentEntryCreated(ETrue);
+		iAttachmentId = McliUtils::GetProgressIdL(*iMsvOperation);
+		iMsvEntry.SetEntryL(iAttachmentId);
+		// we only need to store the attachment if the path is provided - otherwise, only
+		// the entry needs to be created so that the actual attachment can be added later.
+		if(iIsAddByFileHandle || iAttachmentFullName->Length())
+			iState = EStoreAttachment;
+		else if (MultipartMixedCreated() || MultipartRelatedCreated())
+			iState = EMoveOriginalMessageEntryChildrenToNewFolder;
+		else
+			iState = ECompleteStoreMessage;
+		}
+		break;
+	case EStoreAttachment:
+		iStore->CommitL();
+		delete iStore;
+		iStore = NULL;
+		if (MultipartMixedCreated() || MultipartRelatedCreated())
+			iState = EMoveOriginalMessageEntryChildrenToNewFolder;
+		else
+			iState = ECompleteStoreMessage;
+		break;
+	case ECopyOrigMessageToMessage:
+		{
+		iAttachmentId = McliUtils::GetProgressIdL(*iMsvOperation);
+		iState = EAddEntryAttachment;
+		}
+		break;
+	case ECreateMultipartAlternativeFolderEntry:
+		{
+		iAltFolderId = McliUtils::GetProgressIdL(*iMsvOperation);
+		iMsvEntry.SetEntryL(iAltFolderId);
+		SetMultipartAlternativeCreated(ETrue);
+		SetMultipartAlternativeExists(ETrue);
+		// Text Entry was already created without alternative folder .
+		// This is because of change in email settings from Plain (when creating the message)
+		// to Formatted (when sending the message)
+		if(iTextId != KMsvNullIndexEntryId)
+			iState = EMoveTextToAlternativeFolder;
+		else
+			iState = ECreateTextEntry;
+		}
+		break;
+	case EMoveTextToAlternativeFolder:
+		{
+		iState = EStoreRichText;
+		}
+		break;
+	case ECreateTextEntry:
+		if (iTextId == KMsvNullIndexEntryId)
+			{
+			iTextId = McliUtils::GetProgressIdL(*iMsvOperation);
+			}
+		iState = EStoreRichText;
+		break;
+	case EStoreRichText:
+		// a text part has been created ONLY if one did not exist previously
+		SetTextPartCreated(!TextPartExists());
+		if (TextPartExists() && MultipartAlternativeCreated())
+			{
+			// The text entry already existed, but an alternative folder had to
+			// created. This is probably due to the message being originally
+			// plain and then being changed to be an HTML message. Need to create
+			// the HTML entry.
+			iState = ECreateHTMLEntry;
+			}
+		else if (TextPartExists() && iHtmlConverter)
+			{
+			// create HTML alternative if HTML message and text part just created
+			iState = EPrepareToStoreHTMLEntryText;
+			}
+		else if (!HTMLMessage() && !TextPartCreated())
+			{
+			// The message is a non-HTML message, and this is not the first time
+			// that the message body has been stored. Need to remove an HTML
+			// entry if it exists.
+			iState = ERemoveHTMLEntry;
+			}
+		else if (HTMLMessage() && (TextPartCreated() || MultipartAlternativeCreated()))
+			iState = ECreateHTMLEntry;
+		else if (MultipartMixedCreated())
+			iState = EMoveOriginalMessageEntryChildrenToNewFolder;
+		else
+			iState = ECompleteStoreMessage;
+		break;
+	case ECreateHTMLEntry:
+		{
+		iHtmlId = McliUtils::GetProgressIdL(*iMsvOperation);
+		// Store character set info in a MimeHeader.
+		iMsvEntry.SetEntryL(iHtmlId);
+		CMsvStore* store = iMsvEntry.EditStoreL();
+		CleanupStack::PushL(store);
+		CImMimeHeader* mimeHeader = CImMimeHeader::NewLC();
+		mimeHeader->SetMimeCharset(KCharacterSetIdentifierUtf8);
+		mimeHeader->StoreL(*store);
+		store->CommitL();
+		CleanupStack::PopAndDestroy(2,store); //mimeHeader, store
+		iState = EPrepareToStoreHTMLEntryText;
+		}
+		break;
+	case EPrepareToStoreHTMLEntryText:
+		iFinishedConvertingHTML=EFalse;
+		if(iUsePlainTextStorage && iRestoreErr == KErrNoMemory)
+			{
+			// If iRestoreErr is KErrNoMemory then complete the store message operation.
+			iState = ECompleteStoreMessage;
+			}
+		else
+			{
+			iState = iHtmlId ? EStoreHTMLEntryText : ECompleteStoreMessage;
+			}
+		break;
+	case EStoreHTMLEntryText:
+		if (!iFinishedConvertingHTML)
+			break;
+		iState = EStoreHTMLTextInEntry;
+		iHtmlConverter->ResetStoreL();
+		break;
+	case EStoreHTMLTextInEntry:
+		if (MultipartMixedCreated())
+			iState = EMoveOriginalMessageEntryChildrenToNewFolder;
+		else
+			iState = ECompleteStoreMessage;
+		break;
+	case EAddEntryAttachment:
+		{
+		iStore->CommitL();
+		delete iStore;
+		iStore = NULL;
+		if (MultipartMixedCreated() || MultipartRelatedCreated())
+			iState = EMoveOriginalMessageEntryChildrenToNewFolder;
+		else
+			{
+			// AddEntryAsAttachmentL() was called in this state and resets iMsvEntry.
+			// Next state requires that it's set to the messageId
+			// DEF 050410
+			iMsvEntry.SetEntryL(iMessageId);
+			iState = ECompleteStoreMessage;
+			}
+		} break;
+	case ERemoveHTMLEntry:
+		{
+		iState = ECompleteStoreMessage;
+		} break;
+	case EMoveOriginalMessageEntryChildrenToNewFolder:
+		iState = ECompleteStoreMessage;
+		break;
+	case ECompleteStoreMessage:
+		iState = EFinished;
+		break;
+	default:
+		gPanic(EImcmUnknownState);
+		}
+	}
+void CImStoreMessagePart::ChangeStateL()
+	{
+	CMsvOperation* op;
+	switch (iState)
+		{
+	case EFindMultipartRelatedFolder:
+		FindMultipartRelatedFolderL();
+		break;
+	case ECheckForSubfolder:
+		CheckForSubfolderL();
+		break;
+	case ECreateMultipartMixedFolderEntry:
+		CreateMultipartMixedFolderEntryL();
+		break;
+	case ECreateMultipartRelatedFolderEntry:
+		CreateMultipartRelatedFolderEntryL();
+		break;
+	case ECreateAttachmentEntry:
+		CreateAttachmentEntryL();
+		break;
+	case EStoreAttachment:
+		{
+		// store the attachment
+		DoAttachmentStoreL();
+		}
+		break;
+	case ECopyOrigMessageToMessage:
+		CopyOrigMessageToMessageL();
+		break;
+	case ECreateMultipartAlternativeFolderEntry:
+		CreateMultipartAlternativeFolderEntryL();
+		break;
+	case EMoveTextToAlternativeFolder:
+		// This case arrives when the email settings was plain while the message was created and
+		// the setting is changed to formatted (html) while sending.
+		MoveTextEntryToAltFolderL();
+		break;
+	case ECreateTextEntry:
+		CreateTextEntryL();
+		break;
+	case EStoreRichText:
+		StoreRichTextL();
+		break;
+	case ECreateHTMLEntry:
+		CreateHTMLEntryL();
+		break;
+	case EPrepareToStoreHTMLEntryText:
+		TRAP(iRestoreErr ,iHtmlConverter->PrepareToStoreHTMLEntryTextL(iHtmlId, iTextId));
+		// Do not leave if it is KErrNoMemory while creating HTML part for a message, since the
+		// plainbody text part of message is already created and that be used to send the message.
+		if(iUsePlainTextStorage)
+			{
+			if(iRestoreErr != KErrNoMemory)
+				{
+				User::LeaveIfError(iRestoreErr);
+				}
+			}
+		else
+			{
+			User::LeaveIfError(iRestoreErr);
+			}
+		RequestComplete(KErrNone);
+		break;
+	case EStoreHTMLEntryText:
+		iFinishedConvertingHTML = iHtmlConverter->StoreHTMLEntryTextAL(iStatus);
+		if (!iFinishedConvertingHTML)
+			RequestComplete(KErrNone);
+		break;
+	case EStoreHTMLTextInEntry:
+		op = iHtmlConverter->ChangeHTMLTextInEnrtyL(iStatus);
+		if (!op)
+			{
+			RequestComplete(KErrNone);
+			}
+		else
+			{
+			delete iMsvOperation;
+			iMsvOperation = op;
+			}
+		break;
+	case EAddEntryAttachment:
+		AddEntryAsAttachmentL();
+		break;
+	case ERemoveHTMLEntry:
+		{
+		RemoveHTMLEntryL();
+		} break;
+	case EMoveOriginalMessageEntryChildrenToNewFolder:
+		MoveOriginalMessageEntryChildrenToNewFolderL();
+		break;
+	case ECompleteStoreMessage:
+		CompleteStoreMessagePartL();
+		break;
+	case EFinished:
+		{
+		TRequestStatus* status=&iObserverRequestStatus;
+		User::RequestComplete(status,KErrNone);
+		}
+		break;
+	default:
+		gPanic(EImcmUnknownState);
+		}
+	}
+void CImStoreMessagePart::RequestComplete(TInt aError)
+	{
+	iStatus = KRequestPending;
+	TRequestStatus* status=&iStatus;
+	iStatus=KRequestPending;
+	User::RequestComplete(status,aError);
+	}
+void CImStoreMessagePart::Recover()
+	{
+	switch (iState)
+		{
+	case ECreateHTMLEntry:
+	case EStoreRichText:
+	case ERemoveHTMLEntry:
+	case ECreateTextEntry:
+	case ECreateMultipartAlternativeFolderEntry:
+	case ECreateMultipartRelatedFolderEntry:
+	case EPrepareToStoreHTMLEntryText:
+	case EStoreHTMLEntryText:
+		if (MultipartMixedCreated()) // iMixFolderId set when folder created
+			iMsvEntry.Session().RemoveEntry(iMixFolderId);
+		else if (MultipartRelatedCreated())
+			iMsvEntry.Session().RemoveEntry(iRelFolderId);
+		else if (MultipartAlternativeCreated())
+			iMsvEntry.Session().RemoveEntry(iAltFolderId);
+		else if (TextPartCreated())
+			iMsvEntry.Session().RemoveEntry(iTextId);
+		break;
+	case EMoveOriginalMessageEntryChildrenToNewFolder:
+	case ECopyOrigMessageToMessage:
+	case EStoreAttachment:
+	case EMoveTextToAlternativeFolder:
+	case ECreateAttachmentEntry:
+		{
+		if (MultipartMixedCreated())
+			iMsvEntry.Session().RemoveEntry(iMixFolderId);
+		else if (MultipartRelatedCreated())
+			iMsvEntry.Session().RemoveEntry(iRelFolderId);
+		else if (MultipartAlternativeCreated())
+			iMsvEntry.Session().RemoveEntry(iAltFolderId);
+		else if (iAttachmentId != KMsvNullIndexEntryId)
+			iMsvEntry.Session().RemoveEntry(iAttachmentId);
+		}
+		break;
+	// for other states - original message not changed:
+	case ECompleteStoreMessage: // message details may be incorrect but structure is ok to send
+	case ECreateMultipartMixedFolderEntry:
+	case ECheckForSubfolder:
+	case EFindMultipartRelatedFolder:
+	case EFinished:	// operation completed anyway
+		break;
+	default:
+		// shouldn't get to this state
+		__ASSERT_DEBUG(EFalse, gPanic(EImcmUnknownState));
+		}
+	}
+TBool CImStoreMessagePart::HTMLMessage() const
+	{
+	return iFlags & KStoreMessagePartHTMLMessage;
+	}
+void CImStoreMessagePart::SetHTMLMessage(TBool aFlag)
+	{
+	iFlags = (iFlags & ~KStoreMessagePartHTMLMessage) | (aFlag ? KStoreMessagePartHTMLMessage : KStoreMessagePartClearFlag);
+	}
+TBool CImStoreMessagePart::MultipartMixedExists() const
+	{
+	return iFlags & KStoreMessagePartMultipartMixedExists;
+	}
+void CImStoreMessagePart::SetMultipartMixedExists(TBool aFlag)
+	{
+	iFlags = (iFlags & ~KStoreMessagePartMultipartMixedExists) | (aFlag ? KStoreMessagePartMultipartMixedExists : KStoreMessagePartClearFlag);
+	}
+TBool CImStoreMessagePart::MultipartMixedCreated() const
+	{
+	return iFlags & KStoreMessagePartMultipartMixedCreated;
+	}
+void CImStoreMessagePart::SetMultipartMixedCreated(TBool aFlag)
+	{
+	iFlags = (iFlags & ~KStoreMessagePartMultipartMixedCreated) | (aFlag ? KStoreMessagePartMultipartMixedCreated : KStoreMessagePartClearFlag);
+	}
+TBool CImStoreMessagePart::MultipartAlternativeExists() const
+	{
+	return iFlags & KStoreMessagePartMultipartAlternativeExists;
+	}
+void CImStoreMessagePart::SetMultipartAlternativeExists(TBool aFlag)
+	{
+	iFlags = (iFlags & ~KStoreMessagePartMultipartAlternativeExists) | (aFlag ? KStoreMessagePartMultipartAlternativeExists : KStoreMessagePartClearFlag);
+	}
+TBool CImStoreMessagePart::MultipartAlternativeCreated() const
+	{
+	return iFlags & KStoreMessagePartMultipartAlternativeCreated;
+	}
+void CImStoreMessagePart::SetMultipartAlternativeCreated(TBool aFlag)
+	{
+	iFlags = (iFlags & ~KStoreMessagePartMultipartAlternativeCreated) | (aFlag ? KStoreMessagePartMultipartAlternativeCreated : KStoreMessagePartClearFlag);
+	}
+TBool CImStoreMessagePart::MultipartRelatedExists() const
+	{
+	return iFlags & KStoreMessagePartMultipartRelatedExists;
+	}
+void CImStoreMessagePart::SetMultipartRelatedExists(TBool aFlag)
+	{
+	iFlags = (iFlags & ~KStoreMessagePartMultipartRelatedExists) | (aFlag ? KStoreMessagePartMultipartRelatedExists : KStoreMessagePartClearFlag);
+	}
+TBool CImStoreMessagePart::MultipartRelatedCreated() const
+	{
+	return iFlags & KStoreMessagePartMultipartRelatedCreated;
+	}
+void CImStoreMessagePart::SetMultipartRelatedCreated(TBool aFlag)
+	{
+	iFlags = (iFlags & ~KStoreMessagePartMultipartRelatedCreated) | (aFlag ? KStoreMessagePartMultipartRelatedCreated : KStoreMessagePartClearFlag);
+	}
+TBool CImStoreMessagePart::TextPartExists() const
+	{
+	return iFlags & KStoreMessagePartTextPartExists;
+	}
+void CImStoreMessagePart::SetTextPartExists(TBool aFlag)
+	{
+	iFlags = (iFlags & ~KStoreMessagePartTextPartExists) | (aFlag ? KStoreMessagePartTextPartExists : KStoreMessagePartClearFlag);
+	}
+TBool CImStoreMessagePart::TextPartCreated() const
+	{
+	return iFlags & KStoreMessagePartTextPartCreated;
+	}
+void CImStoreMessagePart::SetTextPartCreated(TBool aFlag)
+	{
+	iFlags = (iFlags & ~KStoreMessagePartTextPartCreated) | (aFlag ? KStoreMessagePartTextPartCreated : KStoreMessagePartClearFlag);
+	}
+TBool CImStoreMessagePart::AttachmentEntryCreated() const
+	{
+	return iFlags & KStoreMessagePartAttachmentEntryCreated;
+	}
+void CImStoreMessagePart::SetAttachmentEntryCreated(TBool aFlag)
+	{
+	iFlags = (iFlags & ~KStoreMessagePartAttachmentEntryCreated) | (aFlag ? KStoreMessagePartAttachmentEntryCreated : KStoreMessagePartClearFlag);
+	}
+void CImStoreMessagePart::FindMultipartRelatedFolderL()
+	{
+	TMsvId serviceId = KMsvNullIndexEntryId;
+	TMsvEmailEntry entry;
+	iMsvEntry.Session().GetEntry(iRelatedPartId, serviceId, entry);
+	iMsvEntry.SetEntryL(entry.Parent());
+	entry = iMsvEntry.Entry();
+	switch (entry.MessageFolderType())
+		{
+	case EFolderTypeRelated:
+		iRelFolderId = entry.Id();
+		SetMultipartRelatedExists(ETrue);
+		break;
+	case EFolderTypeAlternative:
+		iAltFolderId = entry.Id();
+		iMsvEntry.Session().GetEntry(iAltFolderId, serviceId, entry);
+		iMsvEntry.SetEntryL(entry.Parent());
+		entry = iMsvEntry.Entry();
+		if (entry.MessageFolderType() == EFolderTypeRelated)
+			{
+			iRelFolderId = entry.Id();
+			SetMultipartRelatedExists(ETrue);
+			}
+		break;
+	default:
+		User::Leave(KErrNotSupported);
+		}
+	RequestComplete(KErrNone);
+	}
+void CImStoreMessagePart::CheckForSubfolderL()
+	{
+	/*
+	//	Check whether the message entry has a multipart mixed folder under it.
+	*/
+	iMsvEntry.SetEntryL(iMessageId);
+	TMsvEmailEntry emailEntry = iMsvEntry.Entry();
+	SetHTMLMessage(emailEntry.MHTMLEmail());
+	if (HTMLMessage())
+		{
+		TRAPD(err,iHtmlConverter=CImHtmlConverter::NewL(iMsvEntry, *iParaLayer, *iCharLayer));
+		if (err)
+			{
+			if (err == KErrNoMemory)
+				User::Leave(KErrNoMemory);
+			else
+				gPanic(EImcmHtmlConverterNotFound);
+			}
+		// Need to check if the Html converter has been created as we only open the resource file
+		// to get the default html attachment name.
+		if (iHtmlConverter)
+			OpenAndReadResourceFileL();
+		}
+	iMessageEntrySelection = iMsvEntry.ChildrenL();
+	CMsvEntrySelection* entrySelection = iMsvEntry.ChildrenWithTypeL(KUidMsvFolderEntry);
+	CleanupStack::PushL(entrySelection);
+	if (entrySelection->Count())
+		{
+		__ASSERT_DEBUG(entrySelection->Count() == 1, gPanic(EImcmMessageEntryHasMoreThanOneFolder));
+		emailEntry = iMsvEntry.ChildDataL((*entrySelection)[0]);
+		if (emailEntry.MessageFolderType() == EFolderTypeMixed)
+			{
+			iMixFolderId = (*entrySelection)[0];
+			SetMultipartMixedExists(ETrue);
+			}
+		else if (emailEntry.MessageFolderType() == EFolderTypeRelated)
+			{
+			iRelFolderId = (*entrySelection)[0];
+			SetMultipartRelatedExists(ETrue);
+			}
+		else if (emailEntry.MessageFolderType() == EFolderTypeAlternative)
+			{
+			iAltFolderId = (*entrySelection)[0];
+			SetMultipartAlternativeExists(ETrue);
+			}
+		}
+	CleanupStack::PopAndDestroy(); // entrySelection
+	iEmailMessage->GetBodyTextEntryIdL(iMessageId, CImEmailMessage::EThisMessageOnly);
+	TBool isPlainText = EFalse;
+	if(iEmailMessage->Selection().Count())
+		{
+		TMsvId textId = iEmailMessage->Selection().At(0);
+		iMsvEntry.SetEntryL(textId);// pointing to the text entry
+		if(iMsvEntry.HasStoreL())
+			{
+			CMsvStore* bodyTextStore = iMsvEntry.ReadStoreL();
+			CleanupStack::PushL(bodyTextStore);
+			// Check if the original message was stored as plain text.
+			if(iUsePlainTextStorage)
+				{
+				isPlainText = (bodyTextStore->IsPresentL(KMsvPlainBodyText16) || bodyTextStore->IsPresentL(KMsvPlainBodyText8));
+				}
+			// This is not a richtext message.
+			if(isPlainText)
+				{
+				CMsvPlainBodyText* textOrig = bodyTextStore->InitialisePlainBodyTextForReadL(KMaxChunkLength);
+				iSizeFwdReplyBody = textOrig->Size();
+				delete textOrig;
+				// Need to release body text store before changing to a new entry
+				CleanupStack::PopAndDestroy(bodyTextStore);
+				iMsvEntry.SetEntryL(iMessageId);
+				TRequestStatus* myStatus=&iStatus;
+				iStatus=KRequestPending;
+				User::RequestComplete(myStatus,KErrNone);
+				}
+			else
+				{
+				CleanupStack::PopAndDestroy(bodyTextStore);
+				iMsvEntry.SetEntryL(iMessageId);
+				iEmailMessage->GetBodyTextL(iStatus, iMessageId, CImEmailMessage::EThisMessageOnly, *iRichText, *iParaLayer, *iCharLayer);
+				}
+			}
+		else
+			{
+			iMsvEntry.SetEntryL(iMessageId);
+			iEmailMessage->GetBodyTextL(iStatus, iMessageId, CImEmailMessage::EThisMessageOnly, *iRichText, *iParaLayer, *iCharLayer);
+			}
+		}
+	else
+		{
+		iMsvEntry.SetEntryL(iMessageId);
+		iEmailMessage->GetBodyTextL(iStatus, iMessageId, CImEmailMessage::EThisMessageOnly, *iRichText, *iParaLayer, *iCharLayer);
+		}
+	}
+void CImStoreMessagePart::CreateMultipartMixedFolderEntryL()
+	{
+	iMsvEntry.SetEntryL(iMessageId);
+	TMsvEmailEntry entry;
+	entry.iType = KUidMsvFolderEntry;
+	entry.iMtm = iMsvEntry.Entry().iMtm;
+	entry.iServiceId = iMsvEntry.Entry().iServiceId;
+	entry.SetMessageFolderType(EFolderTypeMixed);
+	entry.iSize = 0;
+	delete iMsvOperation;
+	iMsvOperation=NULL;
+	iMsvOperation=iMsvEntry.CreateL(entry, iStatus);
+	}
+void CImStoreMessagePart::CreateMultipartRelatedFolderEntryL()
+	{
+	TMsvEmailEntry entry;
+	entry.iType = KUidMsvFolderEntry;
+	entry.iMtm = iMsvEntry.Entry().iMtm;
+	entry.iServiceId = iMsvEntry.Entry().iServiceId;
+	entry.SetMessageFolderType(EFolderTypeRelated);
+	entry.iSize = 0;
+	delete iMsvOperation;
+	iMsvOperation=NULL;
+	iMsvOperation=iMsvEntry.CreateL(entry, iStatus);
+	}
+void CImStoreMessagePart::CreateAttachmentEntryL()
+	{
+	// create the index entry
+	TMsvEntry entry;
+	entry.iMtm = iMsvEntry.Entry().iMtm;
+	entry.iServiceId = iMsvEntry.Entry().iServiceId;
+	entry.iType = KUidMsvAttachmentEntry;
+	entry.iDate.UniversalTime();
+	entry.SetAttachment(ETrue);
+	entry.SetInPreparation(ETrue);
+	TParse parse;
+	if(!iIsAddByFileHandle)
+		{
+	//if the attachment path is set then set details, otherwise just create the entry.
+	if (iAttachmentFullName->Length())
+		{
+		parse.Set(iAttachmentFullName->Des(), NULL, NULL);
+		entry.iDetails.Set(parse.NameAndExt());
+		// Set the size of the attachment
+		TEntry attEntry;
+		iMsvEntry.Session().FileSession().Entry(iAttachmentFullName->Des(), attEntry);
+		iAttachmentSize = attEntry.iSize;
+		entry.iSize = iAttachmentSize;
+		}
+		}
+	else if(iIsAddByFileHandle)
+		{
+		SetEntryDetailsL(entry);
+		}
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	iMsvOperation = iMsvEntry.CreateL(entry, iStatus);
+	}
+void CImStoreMessagePart::DoAttachmentStoreL()
+	{
+	if(iRelatedPartId)
+		{
+		delete iAttachmentInfo;
+		iAttachmentInfo=NULL;
+		iAttachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
+		iAttachmentCreateState = EAddAttachment;
+		}
+	switch(iAttachmentCreateState)
+		{
+	case ECreateAttachment:
+		{
+		CreateAttachmentL();
+		}
+		break;
+	case EAddAttachment:
+		{
+		AddAttachmentL();
+		}
+	break;
+	case EAddAttachmentUsingFileHandle:
+		{
+		AddAttachmentUsingFileHandleL();
+		}
+	break;
+	case  EAddLinkedAttachment:
+		{
+		AddLinkedAttachmentL();
+		}
+	break;
+	case EAddEntryAsAttachment:
+		{
+		AddEntryAsAttachmentL();
+		}
+	break;
+	default:
+	__ASSERT_DEBUG(EFalse, User::Invariant());
+	break;
+		}
+	}
+void CImStoreMessagePart::CreateAttachmentL()
+	{
+	iStore = iMsvEntry.EditStoreL();
+	MMsvAttachmentManager& attachmentMgr = iStore->AttachmentManagerL();
+	attachmentMgr.CreateAttachmentL(iAttachmentFullName->Des(),(*iFileHandle),iAttachmentInfo,iStatus);
+	iAttachmentInfo=NULL;
+	}
+void CImStoreMessagePart::AddAttachmentL()
+	{
+	iStore = iMsvEntry.EditStoreL();
+	MMsvAttachmentManager& attachmentMgr = iStore->AttachmentManagerL();
+	attachmentMgr.AddAttachmentL(iAttachmentFullName->Des(),iAttachmentInfo,iStatus);
+	iAttachmentInfo=NULL;
+	}
+void CImStoreMessagePart::AddAttachmentUsingFileHandleL()
+	{
+	iStore = iMsvEntry.EditStoreL();
+	MMsvAttachmentManager& attachmentMgr = iStore->AttachmentManagerL();
+	attachmentMgr.AddAttachmentL((*iFileHandle),iAttachmentInfo,iStatus);
+	iAttachmentInfo=NULL;
+	}
+void CImStoreMessagePart::AddLinkedAttachmentL()
+	{
+	iStore = iMsvEntry.EditStoreL();
+	MMsvAttachmentManager& attachmentMgr = iStore->AttachmentManagerL();
+	attachmentMgr.AddLinkedAttachmentL(iAttachmentFullName->Des(),iAttachmentInfo,iStatus);
+	iAttachmentInfo=NULL;
+	}
+void CImStoreMessagePart::AddEntryAsAttachmentL()
+	{
+	iMsvEntry.SetEntryL(iAttachmentId);
+	iStore = iMsvEntry.EditStoreL();
+	MMsvAttachmentManager& attachmentMgr = iStore->AttachmentManagerL();
+	attachmentMgr.AddEntryAsAttachmentL(iAttachmentMessageId,iAttachmentInfo,iStatus);
+	iAttachmentInfo=NULL;
+	}
+TInt CImStoreMessagePart::CheckMimeInAttachmentInfoL(CMsvMimeHeaders& aMsvMimeHeaders)
+	{
+	if(!iMsvEntry.HasStoreL())
+		return KErrNotFound;
+	CMsvStore* store  = iMsvEntry.ReadStoreL();
+	CleanupStack::PushL(store);
+	// get the attachment info
+	MMsvAttachmentManager& attachmentMgr = 	store->AttachmentManagerL();
+	TInt mimefound = KErrNotFound;
+	if(attachmentMgr.AttachmentCount())
+		{
+		// one attachment per attachment entry in email
+		CMsvAttachment* attachmentInfo = attachmentMgr.GetAttachmentInfoL(0);
+		CleanupStack::PushL(attachmentInfo);
+		TPtrC8 bufferPtr;
+		// check if attachment info had mimeheaders
+			mimefound =  attachmentInfo->GetDesC8Attribute(KUidMimeHeaders, bufferPtr);
+		// mimeheaders found
+		if(mimefound == KErrNone)
+			aMsvMimeHeaders.RestoreL(*attachmentInfo);
+		CleanupStack::PopAndDestroy(attachmentInfo);
+		}
+	CleanupStack::PopAndDestroy(store);
+	return mimefound;
+	}
+CImMimeHeader* CImStoreMessagePart::ProcessAttachmentMimeHeadersL()
+	{
+	CImMimeHeader* mimeHeader = NULL;
+	CMsvMimeHeaders* msvMimeHeaders = CMsvMimeHeaders::NewLC();
+	TInt err = CheckMimeInAttachmentInfoL(*msvMimeHeaders);
+	if(err == KErrNone)
+		{
+		// convert the CMsvMimeHeaders in attactment info to CImMimeHeader
+		mimeHeader = iEmailMessage->ConvertToImMimeHeadersL(msvMimeHeaders);
+		CleanupStack::PushL(mimeHeader);
+		CMsvStore* store = iMsvEntry.EditStoreL();
+		CleanupStack::PushL(store);
+		mimeHeader->StoreL(*store);
+		store->CommitL();
+		CleanupStack::PopAndDestroy(store);
+		CleanupStack::Pop(mimeHeader);//mimeHeader
+		}
+	CleanupStack::PopAndDestroy(msvMimeHeaders);
+	return mimeHeader;
+	}
+void CImStoreMessagePart::SetEntryDetailsL(TMsvEntry& aEntry)
+	{
+	if(iAttachmentFullName)
+		{
+		// for create attachment name is set by user
+		aEntry.iDetails.Set(iAttachmentFullName->Des());
+		}
+	else
+		{
+		// adding the attachment using file handle. , get the name from handle
+		TFileName fileName;
+		User::LeaveIfError(iFileHandle->Name(fileName));
+		aEntry.iDetails.Set(fileName);
+		}
+	// get the size of the file from the handle	if add by file handle
+	if(iAttachmentCreateState != ECreateAttachment)
+		{
+		iFileHandle->Size(iAttachmentSize);
+		aEntry.iSize = iAttachmentSize;
+		}
+	}
+void CImStoreMessagePart::CopyOrigMessageToMessageL()
+	{
+	TMsvId serviceId;
+	TMsvEmailEntry entry;
+	iMsvEntry.Session().GetEntry(iAttachmentMessageId, serviceId, entry);
+	iMsvEntry.SetEntryL(entry.Parent());
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	if (MultipartMixedCreated() || MultipartMixedExists())
+		iMsvOperation = iMsvEntry.CopyL(iAttachmentMessageId, iMixFolderId, iStatus);
+	else
+		iMsvOperation = iMsvEntry.CopyL(iAttachmentMessageId, iMessageId, iStatus);
+	}
+void CImStoreMessagePart::CreateMultipartAlternativeFolderEntryL()
+	{
+	TMsvEmailEntry entry;
+	entry.iType = KUidMsvFolderEntry;
+	entry.iMtm = iMsvEntry.Entry().iMtm;
+	entry.iServiceId = iMsvEntry.Entry().iServiceId;
+	entry.SetMessageFolderType(EFolderTypeAlternative);
+	entry.iSize = 0;
+	delete iMsvOperation;
+	iMsvOperation=NULL;
+	iMsvOperation=iMsvEntry.CreateL(entry, iStatus);
+	}
+void CImStoreMessagePart::CreateTextEntryL()
+	{
+	// create the index entry
+	TMsvEntry entry;
+	entry.iMtm = iMsvEntry.Entry().iMtm;
+	entry.iServiceId = iMsvEntry.Entry().iServiceId;
+	entry.iType = KUidMsvEmailTextEntry;
+	entry.iDate.UniversalTime();
+	entry.iSize = 0;
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	iMsvOperation = iMsvEntry.CreateL(entry, iStatus);
+	}
+void CImStoreMessagePart::StoreRichTextL()
+	{
+	if(iUsePlainTextStorage)
+		{
+		StorePlainTextL();
+		return;
+		}
+	iMsvEntry.SetEntryL(iTextId);	//pointing to the text entry
+	CMsvStore* store = iMsvEntry.EditStoreL();
+	CleanupStack::PushL(store);
+	store->StoreBodyTextL(*iRichTextToStore);
+	store->CommitL();
+	// Store Mime header if we've got one
+	if ( iMimeHeaderOfBodyText )
+		{
+		iMimeHeaderOfBodyText->StoreL(*store);
+		store->CommitL();
+		iMimeHeaderOfBodyText = NULL;	// We never really took ownership of the object
+		}
+	CleanupStack::PopAndDestroy(store);
+	// update size of text entry
+	TMsvEmailEntry entry(iMsvEntry.Entry());
+	// DocumentLength() gives no. of chars and since unicode we multiply by 2
+	entry.iSize = (iRichTextToStore->DocumentLength() * 2);
+	entry.iDate.UniversalTime();
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	iMsvOperation = iMsvEntry.ChangeL(entry, iStatus);
+	}
+void CImStoreMessagePart::StorePlainTextL()
+	{
+	TUint charset = 0;
+	TBool override = EFalse;
+	iEmailMessage->GetCharacterSetL(iMessageId,charset,override);
+	iMsvEntry.SetEntryL(iTextId);	//pointing to the text entry
+	CMsvStore* store = iMsvEntry.EditStoreL();
+	CleanupStack::PushL(store);
+	iSizeOfBody = 0;
+	// If this method was called as a result of a call to CImEmailMessage::StoreBodyTextL
+	if(iRichTextToStore)
+		{
+		RFs& fileSvrSession = iMsvSession.FileSession();
+		CCnvCharacterSetConverter* characterConverter = CCnvCharacterSetConverter::NewL();
+		CleanupStack::PushL(characterConverter);
+		CImConvertCharconv* charConv = CImConvertCharconv::NewL(*characterConverter, fileSvrSession);
+		CleanupStack::PushL(charConv);
+		TUint defaultCharset =	charConv->SystemDefaultCharset();
+		CleanupStack::PopAndDestroy(2,characterConverter);
+		characterConverter = NULL;
+		charConv = NULL;
+		// Body text is stored in MailStore as 16 bit so set iIs8Bit to EFalse.
+		CMsvPlainBodyText* text = store->InitialisePlainBodyTextForWriteL(EFalse,charset,defaultCharset);
+		CleanupStack::PushL(text);
+		text->StoreRichTextAsPlainTextL(*iRichTextToStore);
+		text->CommitL();
+		CleanupStack::PopAndDestroy(text);
+		}
+	else // If this method was called as a result to a call to CImPlainBodyText::CommitL
+		{
+		// Delete the store since for Read operation we need to open in Read mode.
+		CleanupStack::PopAndDestroy(store);
+		store = NULL;
+		store = iMsvEntry.ReadStoreL();
+		CleanupStack::PushL(store);
+		// The plain bodytext storeoperation is completed when CImPlainBodyText::CommitL is called
+		// Find out the length of the body text here.
+		CMsvPlainBodyText* bodyText = store->InitialisePlainBodyTextForReadL(KMaxChunkLength);
+		iSizeOfBody = bodyText->Size();
+		delete bodyText;
+		CleanupStack::PopAndDestroy(store);
+		store = NULL;
+		// Open it in Edit mode so that store CommitL do not fail.
+		store = iMsvEntry.EditStoreL();
+		CleanupStack::PushL(store);
+		}
+	// Store Mime header if we've got one
+	if ( iMimeHeaderOfBodyText )
+		{
+		iMimeHeaderOfBodyText->StoreL(*store);
+		store->CommitL();
+		iMimeHeaderOfBodyText = NULL;	// We never really took ownership of the object
+		}
+	CleanupStack::PopAndDestroy(store);
+	// update size of text entry
+	TMsvEmailEntry entry(iMsvEntry.Entry());
+	// DocumentLength() gives no. of chars and since unicode we multiply by 2
+	if(iRichTextToStore)
+		{
+		entry.iSize = (iRichTextToStore->DocumentLength() * 2);
+		iSizeOfBody = entry.iSize;
+		}
+	else
+		{
+		entry.iSize = iSizeOfBody;
+		}
+	entry.iDate.UniversalTime();
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	iMsvOperation = iMsvEntry.ChangeL(entry, iStatus);
+	}
+void CImStoreMessagePart::CreateHTMLEntryL()
+	{
+	iMsvEntry.SetEntryL(iAltFolderId);
+	TMsvEntry entry;
+	entry.iServiceId = iMsvEntry.Entry().iServiceId;
+	entry.iType = KUidMsvEmailHtmlEntry;
+	entry.iMtm = iMsvEntry.Entry().iMtm;
+	entry.iDate.UniversalTime();
+	entry.iSize = 0;
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	iMsvOperation = iMsvEntry.CreateL(entry, iStatus);
+	}
+void CImStoreMessagePart::RemoveHTMLEntryL()
+	{
+	// Find the id for the HTML Entry - current entry is the text entry. Set
+	// entry to the parent and verify that this is an EFolderTypeAlternative.
+	// Then search its children for an HTML entry.
+	iHtmlId = KMsvNullIndexEntryId;
+	iMsvEntry.SetEntryL(iMsvEntry.Entry().Parent());
+	if( ((TMsvEmailEntry) iMsvEntry.Entry()).MessageFolderType() != EFolderTypeAlternative )
+		{
+		// Self-complete to continue with state machine.
+		RequestComplete(KErrNone);
+		return;
+		}
+	TInt ii = iMsvEntry.Count();
+	while( ii-- )
+		{
+		if( iMsvEntry[ii].iType == KUidMsvEmailHtmlEntry )
+			{
+			iHtmlId = iMsvEntry[ii].Id();
+			break;
+			}
+		}
+	if( iHtmlId == KMsvNullIndexEntryId )
+		{
+		// There is no HTML entry - self-complete to continue with state machine.
+		RequestComplete(KErrNone);
+		return;
+		}
+	// Delete the HTML entry asynchronously.
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	iMsvOperation = iMsvEntry.DeleteL(iHtmlId, iStatus);
+	}
+void CImStoreMessagePart::MoveTextEntryToAltFolderL()
+	{
+	// moves the text entry to alternativelder entry
+	TMsvId serviceId = KMsvNullIndexEntryId;
+	TMsvEmailEntry entry;
+	iMsvEntry.Session().GetEntry(iTextId, serviceId, entry);
+	iMsvEntry.SetEntryL(entry.Parent());
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	iMsvOperation = iMsvEntry.MoveL(iTextId, iAltFolderId, iStatus);
+	}
+void CImStoreMessagePart::MoveOriginalMessageEntryChildrenToNewFolderL()
+	{
+	if (MultipartRelatedCreated())
+		{
+		// set entry to the multipart/related folders parent and copy the multipart alternative
+		// into the multipart/related.
+		TMsvId serviceId = KMsvNullIndexEntryId;
+		TMsvEmailEntry entry;
+		iMsvEntry.Session().GetEntry(iRelFolderId, serviceId, entry);
+		iMsvEntry.SetEntryL(entry.Parent());
+		delete iMsvOperation;
+		iMsvOperation = NULL;
+		iMsvOperation = iMsvEntry.MoveL(iAltFolderId, iRelFolderId, iStatus);
+		}
+	else //if MultipartMixedCreated()
+		{
+		iMsvEntry.SetEntryL(iMessageId);
+		delete iMsvOperation;
+		iMsvOperation = NULL;
+		iMsvOperation = iMsvEntry.MoveL(*iMessageEntrySelection, iMixFolderId, iStatus);
+		}
+	}
+void CImStoreMessagePart::CompleteStoreMessagePartL()
+	{
+	if (iMsvEntry.Entry().iType != KUidMsvMessageEntry)
+		iMsvEntry.SetEntryL(iMessageId);	//pointing to the message
+	TMsvEmailEntry entry(iMsvEntry.Entry());
+	if (iMessagePart == EMessagePartAttachment)
+		{
+		entry.iSize += iAttachmentSize;
+		entry.SetAttachment(ETrue);
+		}
+	else if (iMessagePart == EMessagePartMessageAttachment)
+		{
+		TMsvId serviceId;
+		TMsvEmailEntry attachmentMessageEntry;
+		iMsvEntry.Session().GetEntry(iAttachmentMessageId, serviceId, attachmentMessageEntry);
+		entry.SetAttachment(ETrue);
+		entry.iSize += attachmentMessageEntry.iSize;
+		}
+	else if (iMessagePart == EMessagePartBody)
+		{
+		if(iUsePlainTextStorage)
+			{
+			entry.iSize -= iSizeFwdReplyBody; // first subtract length of original plain text.
+			entry.iSize += iSizeOfBody;
+			}
+		else
+			{
+			// DocumentLength() gives no. of chars and since unicode we multiply by 2
+			entry.iSize -= (iRichText->DocumentLength() * 2); // first subtract length of original RichText
+			entry.iSize += (iRichTextToStore->DocumentLength() * 2);
+			}
+		}
+	if (iHtmlConverter)
+		entry.iSize+=iHtmlConverter->Size();
+	entry.iDate.UniversalTime();
+	StoreMimeHeaderL();
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	entry.SetInPreparation(EFalse);
+	iMsvOperation = iMsvEntry.ChangeL(entry, iStatus);
+	}
+void CImStoreMessagePart::StoreMimeHeaderL()
+	{
+	CImMimeHeader* mimeHeader = NULL;
+	if (MultipartMixedCreated() || MultipartAlternativeCreated() || MultipartRelatedCreated())
+		{
+		CMsvStore* store = iMsvEntry.EditStoreL();
+		CleanupStack::PushL(store);
+		mimeHeader = CImMimeHeader::NewLC();
+		CreateFolderMimeHeaderL(*mimeHeader);
+		mimeHeader->StoreL(*store);
+		store->CommitL();
+		CleanupStack::PopAndDestroy(2); //mimeHeader, store
+		}
+	if (iMessagePart==EMessagePartAttachment && iAttachmentId)
+		{
+		TMsvId oldId = iMsvEntry.Entry().Id();
+		iMsvEntry.SetEntryL(iAttachmentId);
+		mimeHeader = NULL;
+		mimeHeader = ProcessAttachmentMimeHeadersL();
+		// mimeheader not found in attachment info, hence create mime header
+		if (mimeHeader == NULL)
+			{
+			mimeHeader = CImMimeHeader::NewLC();
+			if (CreateAttachmentMimeHeaderL(*mimeHeader, iMsvEntry.Entry().iDetails))
+				{
+				CMsvStore* store = iMsvEntry.EditStoreL();
+				CleanupStack::PushL(store);
+				mimeHeader->StoreL(*store);
+				store->CommitL();
+				CleanupStack::PopAndDestroy(store);
+				}
+			CleanupStack::PopAndDestroy(mimeHeader);
+			}
+		else
+			{
+			delete mimeHeader;
+			}
+		iMsvEntry.SetEntryL(oldId); // Reset
+		}
+	else if (iMessagePart==EMessagePartMessageAttachment && iAttachmentMessageId)
+		{
+		CMsvStore* store = iMsvEntry.EditStoreL();
+		CleanupStack::PushL(store);
+		mimeHeader = CImMimeHeader::NewLC();
+		CreateMessageMimeHeaderL(*mimeHeader);
+		mimeHeader->StoreL(*store);
+		store->CommitL();
+		CleanupStack::PopAndDestroy(2); //mimeHeader, store
+		}
+	}
+void CImStoreMessagePart::CreateFolderMimeHeaderL(CImMimeHeader& aMimeHeader)
+	{
+	aMimeHeader.SetContentTypeL(KMimeMultipart);
+	if (MultipartMixedCreated())
+		aMimeHeader.SetContentSubTypeL(KMimeMixed);
+	else if (MultipartRelatedCreated())
+		aMimeHeader.SetContentSubTypeL(KMimeRelated);
+	else
+		aMimeHeader.SetContentSubTypeL(KMimeAlternative);
+	aMimeHeader.SetContentTransferEncodingL(KMimeQuotedPrintable);
+	}
+void CImStoreMessagePart::CreateMessageMimeHeaderL(CImMimeHeader& aMimeHeader)
+	{
+	aMimeHeader.SetContentTypeL(KMimeMessage);
+	aMimeHeader.SetContentSubTypeL(KMimeRfc822);
+	}
+TBool CImStoreMessagePart::CreateAttachmentMimeHeaderL(CImMimeHeader& aMimeHeader, const TDesC& aDetails)
+/**
+Opens attachment file & extract initial text, pass into recognizer.
+If the file type is recognized, use the MIME string produced in
+the MIMEheader object stored in the attachment entry.
+*/
+	{
+	if (!aDetails.Length())
+		return EFalse; // No file to check
+	RApaLsSession lsSession;
+	if (lsSession.Connect() != KErrNone)
+		{
+		// Unable to connect to Recognizer server.
+		return EFalse;
+		}
+	CleanupClosePushL(lsSession);
+	TDataRecognitionResult result;
+	User::LeaveIfError(lsSession.RecognizeData(aDetails, TPtrC8(), result));
+	TPtrC8 mimeBuf8=result.iDataType.Des8();
+	if (!mimeBuf8.Length())
+		{
+		// No point passing the file handle to the recogniser for Create Attachment
+		// as it will be zero length
+		if(iAttachmentCreateState != ECreateAttachment)
+			{
+			CMsvStore* store = iMsvEntry.ReadStoreL();
+			CleanupStack::PushL(store);
+			MMsvAttachmentManager& attachmentMgr = store->AttachmentManagerL();
+			// as this is email attachment entry , it has one attachment per entry
+			RFile file = attachmentMgr.GetAttachmentFileL(0);
+			CleanupStack::PopAndDestroy(store);
+			CleanupClosePushL(file);
+			// pass the handle to the recogniser instead of filepath
+			User::LeaveIfError(lsSession.RecognizeData(file, result));
+			CleanupStack::PopAndDestroy(&file);
+	   		mimeBuf8.Set(result.iDataType.Des8());
+			}
+		if (!mimeBuf8.Length())
+			{
+			CleanupStack::PopAndDestroy(); // lssession
+			return EFalse;
+			}
+		}
+	TInt locatePos = mimeBuf8.Locate(TChar('/'));
+	if (locatePos != KErrNotFound)
+		{
+		aMimeHeader.SetContentTypeL(mimeBuf8.Left(locatePos));
+		aMimeHeader.SetContentSubTypeL(mimeBuf8.Mid(locatePos + 1));
+		}
+	if (iRelatedPartId)
+		aMimeHeader.SetContentIDL(*iContentId);
+	CleanupStack::PopAndDestroy(); // lssession
+	return ETrue;
+	}
+//	---------------------------------------------------------------------
+//	Class to create receipts, replies, forwarded emails, and new emails
+//	---------------------------------------------------------------------
+/** Creates a new email message.
+@param aObserverRequestStatus Asynchronous status word to complete when the
+operation completes
+@param aMsvSession Message server session to use
+@param aDestination The Id of the folder where the new message is to be created
+@param aPartList The body parts that are required in the new message. If a
+message with body text and attachments is required, then the KMsvMessagePartBody
+and KMsvMessagePartAttachments parts have to be set.
+@param aMsvEmailTypeList Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType The type of message to create e.g. KUidMsgTypeSMTP.
+@return Operation object by which to control the operation */
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateNewL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aDestination, TMsvPartList aPartList, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, KMsvUnknownServiceIndexEntryId, aPartList, aMsvEmailTypeList, aMsgType, EPriorityStandard, EFalse);
+	CleanupStack::PushL(self);
+	self->ConstructL(ENew);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/** Creates a new email message with a specified priority and SMTP service.
+@param aObserverRequestStatus Asynchronous status word to complete when the
+operation completes
+@param aMsvSession Message server session to use
+@param aDestination The Id of the folder where the new message is to be created
+@param aSmtpServiceId The Id of the SMTP service entry to handle the email
+@param aPartList The body parts that are required in the new message. If a
+message with body text and attachments is required, then the KMsvMessagePartBody
+and KMsvMessagePartAttachments parts have to be set.
+@param aMsvEmailTypeList Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType The type of message to create e.g. KUidMsgTypeSMTP.
+@param aPriority The priority setting for the email
+@return Operation object by which to control the operation */
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateNewL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aDestination, TMsvId aSmtpServiceId, TMsvPartList aPartList, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType, TInt aPriority)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, aSmtpServiceId, aPartList, aMsvEmailTypeList, aMsgType, aPriority, EFalse);
+	CleanupStack::PushL(self);
+	self->ConstructL(ENew);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/**
+Creates a new plain text email message with a specified priority and SMTP service.
+@param aObserverRequestStatus  	Asynchronous status word to complete when the
+								operation completes
+@param aMsvSession 				Message server session to use
+@param aDestination 			The Id of the folder where the new message is to be created
+@param aSmtpServiceId 			The Id of the SMTP service entry to handle the email
+@param aPartList 				The body parts that are required in the new message. If a
+								message with body text and attachments is required, then the KMsvMessagePartBody
+								and KMsvMessagePartAttachments parts have to be set.
+@param aMsvEmailTypeList 		Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+								KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+								If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType 				The type of message to create e.g. KUidMsgTypeSMTP.
+@param aPriority 				The priority setting for the email- by default this must be EPriorityStandard.
+@param aUsePlainTextStorage		TBool, if set to ETrue inidcates that the new message entry needs to be created as plain text
+								if set to EFalse indicates that message will be created as richtext entry.
+@return CImEmailOperation		Operation object by which to control the operation
+*/
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateNewL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aDestination, TMsvId aSmtpServiceId, TMsvPartList aPartList, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType, TInt aPriority, TBool aUsePlainTextStorage)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, aSmtpServiceId, aPartList, aMsvEmailTypeList, aMsgType, aPriority, aUsePlainTextStorage);
+	CleanupStack::PushL(self);
+	self->ConstructL(ENew);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/** Creates a reply email message, overriding the default subject format string.
+The aFormatString parameter allows you to override the default string used
+in the subject field of the new message (the default is the localised string
+STRING_reply_formatting_string1 defined in the source file imcm.rls).
+Note that if you reply to an HTML message that does not contain a text/plain
+alternative to the HTML, then the HTML part is copied as an attachment (still
+an HTML entry) into the new message even if aPartList does not specify KMsvMessagePartAttachments.
+This occurs because there is no other way of reading the original message
+unless the user switches between the editor/viewer and the application.
+@param aObserverRequestStatus Asynchronous status word to complete when the
+operation completes
+@param aMsvSession Message server session to use
+@param aMessageId The Id of the message to reply to
+@param aDestination The Id of the folder where the new message is to be created
+@param aPartList The body parts that are required in the new message. If a
+message with body text is required, then set KMsvMessagePartBody; if attachments
+are required too, also set KMsvMessagePartAttachments. To reply to the originator
+only, set KMsvMessagePartOriginator, otherwise a reply will be sent to all
+recipients of the original message. If the subject field is not required,
+then do not set KMsvMessagePartDescription.
+@param aFormatString A string to be inserted into the subject field in the
+header before the subject, e.g. "Re: %S", sets the field to be "Re: " followed
+by the original subject text
+@param aMsvEmailTypeList Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType The type of message to create e.g. KUidMsgTypeSMTP.
+@return Operation object by which to control the operation */
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateReplyL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aMessageId, TMsvId aDestination, TMsvPartList aPartList, const TDesC& aFormatString, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, KMsvUnknownServiceIndexEntryId, aPartList, aMsvEmailTypeList, aMsgType, EPriorityStandard, EFalse);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMessageId, aFormatString, EReply);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/** Creates a reply email message.
+For details of how replies to HTML messages are handled, see the description
+above for the first overload of this function.
+@param aObserverRequestStatus Asynchronous status word to complete when the
+operation completes
+@param aMsvSession Message server session to use
+@param aMessageId The Id of the message to reply to
+@param aDestination The Id of the folder where the new message is to be created
+@param aPartList The body parts that are required in the new message. If a
+message with body text and attachments is required, then the KMsvMessagePartBody
+and KMsvMessagePartAttachments parts have to be set.
+@param aMsvEmailTypeList Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType The type of message to create e.g. KUidMsgTypeSMTP.
+@return Operation object by which to control the operation */
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateReplyL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aMessageId, TMsvId aDestination, TMsvPartList aPartList, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, KMsvUnknownServiceIndexEntryId, aPartList, aMsvEmailTypeList, aMsgType, EPriorityStandard, EFalse);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMessageId, EReply);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/** Creates a reply email message, specifying a message priority.
+For details of how replies to HTML messages are handled, see the description
+above for the first overload of this function.
+@param aObserverRequestStatus Asynchronous status word to complete when the
+operation completes
+@param aMsvSession Message server session to use
+@param aMessageId The Id of the message to reply to
+@param aDestination The Id of the folder where the new message is to be created
+@param aPartList The body parts that are required in the new message. If a
+message with body text and attachments is required, then the KMsvMessagePartBody
+and KMsvMessagePartAttachments parts have to be set.
+@param aMsvEmailTypeList Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType The type of message to create e.g. KUidMsgTypeSMTP.
+@param aPriority The priority setting for the email
+@return Operation object by which to control the operation */
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateReplyL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aMessageId, TMsvId aDestination, TMsvPartList aPartList, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType, TInt aPriority)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, KMsvUnknownServiceIndexEntryId, aPartList, aMsvEmailTypeList, aMsgType, aPriority, EFalse);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMessageId, EReply);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/** Creates a reply email message, specifying a message priority.
+For details of how replies to HTML messages are handled, see the description
+above for the first overload of this function.
+@param aObserverRequestStatus Asynchronous status word to complete when the
+operation completes
+@param aMsvSession Message server session to use
+@param aMessageId The Id of the message to reply to
+@param aDestination The Id of the folder where the new message is to be created
+@param aPartList The body parts that are required in the new message. If a
+message with body text and attachments is required, then the KMsvMessagePartBody
+and KMsvMessagePartAttachments parts have to be set.
+@param aMsvEmailTypeList Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType The type of message to create e.g. KUidMsgTypeSMTP.
+@param aPriority The priority setting for the email
+@param aUsePlainTextStorage		TBool, if set to ETrue inidcates that the new message entry needs to be created as plain text
+								if set to EFalse indicates that message will be created as richtext entry.
+@return Operation object by which to control the operation */
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateReplyL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aMessageId, TMsvId aDestination, TMsvPartList aPartList, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType, TInt aPriority, TBool aUsePlainTextStorage)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, KMsvUnknownServiceIndexEntryId, aPartList, aMsvEmailTypeList, aMsgType, aPriority, aUsePlainTextStorage);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMessageId, EReply);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/** Creates a forwarded email message, overriding the default subject format string.
+The aFormatString parameter allows you to override the default string used
+in the subject field of the new message (the default is the localised string
+STRING_forward_formatting_string1 defined in the source file imcm.rls).
+Note that if you forward an HTML message that does not contain a text/plain
+alternative to the HTML, then the HTML part is copied as an attachment (still
+an HTML entry) into the new message even if aPartList does not specify KMsvMessagePartAttachments.
+This occurs because there is no other way of reading the original message
+unless the user switches between the editor/viewer and the application.
+@param aObserverRequestStatus Asynchronous status word to complete when the
+operation completes
+@param aMsvSession Message server session to use
+@param aMessageId The Id of the message to forward
+@param aDestination The Id of the folder where the new message is to be created
+@param aPartList The body parts that are required in the new message. If a
+message with body text and attachments is required, then the KMsvMessagePartBody
+and KMsvMessagePartAttachments parts have to be set.
+@param aFormatString A string to be inserted into the subject field in the
+header before the subject, e.g. "Fwd: %S", sets the field to be "Fwd: " followed
+by the original subject text
+@param aMsvEmailTypeList Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType The type of message to create e.g. KUidMsgTypeSMTP.
+@return Operation object by which to control the operation */
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateForwardL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aMessageId, TMsvId aDestination, TMsvPartList aPartList, const TDesC& aFormatString, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, KMsvUnknownServiceIndexEntryId,  aPartList, aMsvEmailTypeList, aMsgType, EPriorityStandard, EFalse);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMessageId, aFormatString, EForward);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/** Creates a forwarded email message.
+For details of how forwarding HTML messages is handled, see the description
+above for the first overload of this function.
+@param aObserverRequestStatus Asynchronous status word to complete when the
+operation completes
+@param aMsvSession Message server session to use
+@param aMessageId The Id of the message to forward
+@param aDestination The Id of the folder where the new message is to be created
+@param aPartList The body parts that are required in the new message. If a
+message with body text and attachments is required, then the KMsvMessagePartBody
+and KMsvMessagePartAttachments parts have to be set.
+@param aMsvEmailTypeList Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType The type of message to create e.g. KUidMsgTypeSMTP.
+@return Operation object by which to control the operation */
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateForwardL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aMessageId, TMsvId aDestination, TMsvPartList aPartList, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, KMsvUnknownServiceIndexEntryId,  aPartList, aMsvEmailTypeList, aMsgType, EPriorityStandard, EFalse);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMessageId, EForward);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/** Creates a forwarded email message, specifying the message priority and SMTP
+service with which to send the message.
+For details of how forwarding HTML messages is handled, see the description
+above for the first overload of this function.
+@param aObserverRequestStatus Asynchronous status word to complete when the
+operation completes
+@param aMsvSession Message server session to use
+@param aMessageId The Id of the message to forward
+@param aDestination The Id of the folder where the new message is to be created
+@param aSmtpServiceId The Id of the SMTP service with which to send the new
+message
+@param aPartList The body parts that are required in the new message. If a
+message with body text and attachments is required, then the KMsvMessagePartBody
+and KMsvMessagePartAttachments parts have to be set.
+@param aMsvEmailTypeList Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType The type of message to create e.g. KUidMsgTypeSMTP.
+@param aPriority The priority setting for the email
+@return Operation object by which to control the operation */
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateForwardL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aMessageId, TMsvId aDestination, TMsvId aSmtpServiceId, TMsvPartList aPartList, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType, TInt aPriority)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, aSmtpServiceId, aPartList, aMsvEmailTypeList, aMsgType, aPriority, EFalse);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMessageId, EForward);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/** Creates a forwarded email message, specifying the message priority and SMTP
+service with which to send the message.
+For details of how forwarding HTML messages is handled, see the description
+above for the first overload of this function.
+@param aObserverRequestStatus Asynchronous status word to complete when the
+operation completes
+@param aMsvSession Message server session to use
+@param aMessageId The Id of the message to forward
+@param aDestination The Id of the folder where the new message is to be created
+@param aSmtpServiceId The Id of the SMTP service with which to send the new
+message
+@param aPartList The body parts that are required in the new message. If a
+message with body text and attachments is required, then the KMsvMessagePartBody
+and KMsvMessagePartAttachments parts have to be set.
+@param aMsvEmailTypeList Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType The type of message to create e.g. KUidMsgTypeSMTP.
+@param aPriority The priority setting for the email
+@param aUsePlainTextStorage		TBool, if set to ETrue inidcates that the new message entry needs to be created as plain text
+								if set to EFalse indicates that message will be created as richtext entry.
+@return Operation object by which to control the operation */
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateForwardL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aMessageId, TMsvId aDestination, TMsvId aSmtpServiceId, TMsvPartList aPartList, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType, TInt aPriority, TBool aUsePlainTextStorage)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, aSmtpServiceId, aPartList, aMsvEmailTypeList, aMsgType, aPriority, aUsePlainTextStorage);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMessageId, EForward);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/** Creates a forwarded email message.
+@param aObserverRequestStatus Asynchronous status word to complete when the
+operation completes
+@param aMsvSession Message server session to use
+@param aMessageId The Id of the message to forward
+@param aDestination The Id of the folder where the new message is to be created
+@param aPartList The body parts that are required in the new message. If a
+message with body text and attachments is required, then the KMsvMessagePartBody
+and KMsvMessagePartAttachments parts have to be set.
+@param aMsvEmailTypeList Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType The type of message to create e.g. KUidMsgTypeSMTP.
+@return Operation object by which to control the operation */
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateForwardAsAttachmentL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aMessageId, TMsvId aDestination, TMsvPartList aPartList, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, KMsvUnknownServiceIndexEntryId, aPartList, aMsvEmailTypeList, aMsgType, EPriorityStandard, EFalse);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMessageId, EForwardAsAttachment);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/** Creates a forwarded email message, specifying the message priority and SMTP
+service with which to send the message.
+@param aObserverRequestStatus Asynchronous status word to complete when the
+operation completes
+@param aMsvSession Message server session to use
+@param aMessageId The Id of the message to forward
+@param aSmtpServiceId The Id of the SMTP service with which to send the new
+message
+@param aDestination The Id of the folder where the new message is to be created
+@param aPartList The body parts that are required in the new message. If a
+message with body text and attachments is required, then the KMsvMessagePartBody
+and KMsvMessagePartAttachments parts have to be set.
+@param aMsvEmailTypeList Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType The type of message to create e.g. KUidMsgTypeSMTP.
+@param aPriority The priority setting for the email
+@return Operation object by which to control the operation */
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateForwardAsAttachmentL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aMessageId, TMsvId aDestination, TMsvId aSmtpServiceId, TMsvPartList aPartList, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType, TInt aPriority)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, aSmtpServiceId, aPartList, aMsvEmailTypeList, aMsgType, aPriority, EFalse);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMessageId, EForwardAsAttachment);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/** Creates a email receipt message, overriding the default subject format string.
+The aFormatString parameter allows you to override the default string used
+in the subject field of the new message (the default is the localised string
+STRING_receipt_formatting_string1 defined in the source file imcm.rls).
+@param aObserverRequestStatus Asynchronous status word to complete when the
+operation completes
+@param aMsvSession Message server session to use
+@param aMessageId The Id of the original message for which the receipt is required
+@param aDestination The Id of the folder where the new message is to be created
+@param aPartList The body parts that are required in the new message. If a
+message with body text and attachments is required, then the KMsvMessagePartBody
+and KMsvMessagePartAttachments parts have to be set.
+@param aFormatString A string to be inserted into the subject field in the
+header before the subject, e.g. "Receipt of message: %S", sets the field to
+be "Receipt of message: " followed by the original subject text
+@param aMsvEmailTypeList Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType The type of message to create e.g. KUidMsgTypeSMTP.
+@return Operation object by which to control the operation */
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateReceiptL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aMessageId, TMsvId aDestination, TMsvPartList aPartList, const TDesC& aFormatString, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination,KMsvUnknownServiceIndexEntryId, aPartList, aMsvEmailTypeList, aMsgType, EPriorityStandard, EFalse);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMessageId, aFormatString, EReceipt);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/** Creates a email receipt message.
+@param aObserverRequestStatus Asynchronous status word to complete when the
+operation completes
+@param aMsvSession Message server session to use
+@param aMessageId The Id of the original message for which the receipt is required
+@param aDestination The Id of the folder where the new message is to be created
+@param aPartList The body parts that are required in the new message. If a
+message with body text and attachments is required, then the KMsvMessagePartBody
+and KMsvMessagePartAttachments parts have to be set.
+@param aMsvEmailTypeList Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType The type of message to create e.g. KUidMsgTypeSMTP.
+@return Operation object by which to control the operation */
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateReceiptL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aMessageId, TMsvId aDestination, TMsvPartList aPartList, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, KMsvUnknownServiceIndexEntryId, aPartList, aMsvEmailTypeList, aMsgType, EPriorityStandard, EFalse);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMessageId, EReceipt);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/** Creates a email receipt message, specifying the message priority.
+@param aObserverRequestStatus Asynchronous status word to complete when the
+operation completes
+@param aMsvSession Message server session to use
+@param aMessageId The Id of the original message for which the receipt is required
+@param aDestination The Id of the folder where the new message is to be created
+@param aPartList The body parts that are required in the new message. If a
+message with body text and attachments is required, then the KMsvMessagePartBody
+and KMsvMessagePartAttachments parts have to be set.
+@param aMsvEmailTypeList Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType The type of message to create e.g. KUidMsgTypeSMTP.
+@param aPriority The priority setting for the email
+@return Operation object by which to control the operation */
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateReceiptL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aMessageId, TMsvId aDestination, TMsvPartList aPartList, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType, TInt aPriority)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, KMsvUnknownServiceIndexEntryId, aPartList, aMsvEmailTypeList, aMsgType, aPriority, EFalse);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMessageId, EReceipt);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/** Creates a email receipt message, specifying the message priority.
+@param aObserverRequestStatus Asynchronous status word to complete when the
+operation completes
+@param aMsvSession Message server session to use
+@param aMessageId The Id of the original message for which the receipt is required
+@param aDestination The Id of the folder where the new message is to be created
+@param aPartList The body parts that are required in the new message. If a
+message with body text and attachments is required, then the KMsvMessagePartBody
+and KMsvMessagePartAttachments parts have to be set.
+@param aMsvEmailTypeList Creation flags. This can be 0, or a bitmask of KMsvEmailTypeListMHTMLMessage,
+KMsvEmailTypeListInvisibleMessage, and KMsvEmailTypeListMessageInPreparation.
+If KMsvEmailTypeListMHTMLMessage is not set, a plain-text message is created.
+@param aMsgType The type of message to create e.g. KUidMsgTypeSMTP.
+@param aPriority The priority setting for the email
+@param aUsePlainTextStorage		TBool, if set to ETrue inidcates that the new message entry needs to be created as plain text
+								if set to EFalse indicates that message will be created as richtext entry.
+@return Operation object by which to control the operation */
+EXPORT_C CImEmailOperation* CImEmailOperation::CreateReceiptL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aMessageId, TMsvId aDestination, TMsvPartList aPartList, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType, TInt aPriority, TBool aUsePlainTextStorage)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, KMsvUnknownServiceIndexEntryId, aPartList, aMsvEmailTypeList, aMsgType, aPriority, aUsePlainTextStorage);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMessageId, EReceipt);
+	CleanupStack::Pop(self);
+	return self;
+	}
+CImEmailOperation* CImEmailOperation::CreateCopyL(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aMessageId, TMsvId aDestination, TMsvPartList aPartList, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType)
+	{
+	CImEmailOperation* self = new(ELeave) CImEmailOperation(aObserverRequestStatus, aMsvSession, aDestination, KMsvUnknownServiceIndexEntryId,  aPartList, aMsvEmailTypeList, aMsgType, EPriorityStandard, EFalse);
+	CleanupStack::PushL(self);
+	self->ConstructL(aMessageId, ECopy);
+	CleanupStack::Pop(self);
+	return self;
+	}
+/** Destructor. */
+EXPORT_C CImEmailOperation::~CImEmailOperation()
+	{
+	Cancel();
+	delete iMsvOperation;
+	delete iFormatString;
+	delete iRichText;
+	delete iParaLayer;
+	delete iCharLayer;
+	delete iEmailMessage;
+	delete iNewHeader;
+	delete iFileMan;
+	delete iBodyHeaderFormatString;
+	delete iBodyHeaderDateTimeFormatString;
+	delete iBodyHeader;
+	iAttachmentInfoList.ResetAndDestroy();
+	iFile.Close();
+	delete iStore;
+	delete iMsvEntry;
+	delete iSignatureText;
+	delete iDefaultVCardNameFormatString;
+	delete iHtmlConverter;
+	delete iSmtpSettings;
+	delete iVcardStore;
+	delete iBodyHeaderToString;
+	delete iBodyHeaderCcString;
+	iOriginalHeader = NULL;
+	delete iOriginalHeader;
+	}
+/** Gets progress information for a completed operation.
+The function returns (in packaged form):
+for a successfully completed operation, the Id of the new message
+if there was an error/problem while creating the message, a null Id (KMsvNullIndexEntryId).
+The new message will also be deleted.
+@return A message Id as a TPckg<TMsvId> */
+EXPORT_C const TDesC8& CImEmailOperation::FinalProgress()
+	{
+	__ASSERT_ALWAYS(!IsActive(), gPanic(EMiutActiveInFinalProgress));
+	const TDesC8* progress = &KNullDesC8();
+	TRAPD(leave, progress = &ProgressL());
+	__ASSERT_ALWAYS(leave == KErrNone, gPanic(EImcmFinalProgressFailed));
+	return *progress;
+	}
+/** Gets progress information.
+While the operation is in progress, a null Id (KMsvNullIndexEntryId) is returned.
+For a completed operation, values are as described for FinalProgress().
+@return A message Id as a TPckg<TMsvId> */
+const TDesC8& CImEmailOperation::ProgressL()
+	{
+	if (iState==EFinished)
+		iDataMember() = iNewMessageId;
+	return iDataMember;
+	}
+void CImEmailOperation::DoCancel()
+	{
+	if (iMsvOperation)
+		iMsvOperation->Cancel();
+	if (iEmailMessage)
+		iEmailMessage->Cancel();
+	if (iNewMessageId!=KMsvNullIndexEntryId)
+		iMsvEntry->Session().RemoveEntry(iNewMessageId);
+	TRequestStatus* st = &iObserverRequestStatus;
+	User::RequestComplete(st, KErrCancel);
+	}
+void CImEmailOperation::SelectAndProcessNextStateL()
+	{
+	SelectNextStateL();
+	ProcessStateL();
+	}
+void CImEmailOperation::RunL()
+	{
+	if (iStatus.Int() != KErrNone)
+		{
+		ErrorRecovery(iStatus.Int());
+		return;
+		}
+	if ((iState == ECreateNewMessageEntry) ||
+		(iState == ECreateMultipartMixedFolderEntry) ||
+		(iState == ECreateTextEntry) ||
+		(iState == EStoreBody) ||
+		(iState == ECreateAttachmentEntry) ||
+		(iState == ECreateMultipartAlternativeFolderEntry) ||
+		(iState == ECreateHTMLEntry) ||
+		(iState == EStoreAttachment) ||
+		(iState == ECreateVCardAttachment) ||
+		(iState == ECompleteEmailOperation)
+		|| (iState == ECreateDefaultHtmlAttachment)
+		|| (iState == EStoreHTMLTextInEntry)
+		)
+		{
+		TInt progressError = McliUtils::GetProgressErrorL(*iMsvOperation);
+		if (progressError != KErrNone)
+			{
+			ErrorRecovery(progressError);
+			return;
+			}
+		}
+	if (iState != EFinished)
+		{
+		TRAPD(error, SelectAndProcessNextStateL());
+		if (error)
+			{
+			ErrorRecovery(error);
+			return;
+			}
+		else if (iState != EFinished)
+			SetActive();
+		}
+	}
+CImEmailOperation::CImEmailOperation(TRequestStatus& aObserverRequestStatus, CMsvSession& aMsvSession, TMsvId aDestination, TMsvId aSmtpServiceId, TMsvPartList aPartList, const TMsvEmailTypeList& aMsvEmailTypeList, TUid aMsgType, TInt aPriority, TBool aUsePlainTextStorage)
+	: CMsvOperation(aMsvSession, aPriority, aObserverRequestStatus),
+	  iDestinationId(aDestination),
+	  iSmtpServiceId(aSmtpServiceId),
+	  iMsgType(aMsgType),
+	  iPartList(aPartList),
+	  iMsvEmailTypeList(aMsvEmailTypeList),
+	  iAttachmentFile(aMsvSession.FileSession()),
+	  iUsePlainTextStorage(aUsePlainTextStorage)
+	{
+	iMtm = iMsgType;
+	}
+void CImEmailOperation::ConstructL(TMsvId aMessageId, const TDesC& aFormatString, TImEmailOperation aOperation)
+	{
+iOrigMessageId = aMessageId;
+	iFormatString = aFormatString.AllocL();
+	ConstructL(aOperation);
+	}
+void CImEmailOperation::ConstructL(TMsvId aMessageId, TImEmailOperation aOperation)
+	{
+iOrigMessageId = aMessageId;
+	ConstructL(aOperation);
+	}
+void CImEmailOperation::ConstructL(TImEmailOperation aOperation)
+	{
+	iOperation = aOperation;
+	iMsvEntry = CMsvEntry::NewL(iMsvSession, iDestinationId, TMsvSelectionOrdering());
+	iSmtpSettings = new (ELeave) CImSmtpSettings;
+	if( iMsgType == KUidMsgTypeSMTP )
+		{
+		// Restore the SMTP settings - check if the service has been supplied.
+		if( iSmtpServiceId == KMsvNullIndexEntryId || iSmtpServiceId == KMsvUnknownServiceIndexEntryId )
+			{
+			// Nope - the operation dictates where the SMTP settings are restored
+			// from.
+			switch( iOperation )
+				{
+			case EReply:
+			case EReceipt:
+			case EForward:
+			case EForwardAsAttachment:
+				{
+				// Restore from the original message.
+				TRAPD(error, SetSmtpServiceFromOriginalMessageL());
+				if( error != KErrNone )
+					{
+					// Failed to restore the SMTP settings from the original
+					// message - use the SMTP settings from the default settings
+					// specified in the root entry.
+					SetSmtpServiceFromDefaultsL();
+					}
+				} break;
+			case ENew:
+			case ECopy:
+				{
+				// No SMTP service has been supplied - restore SMTP settings
+				// from the default service specified in the root entry.
+				SetSmtpServiceFromDefaultsL();
+				} break;
+			default:
+				__ASSERT_DEBUG( EFalse, User::Invariant() );
+				break;
+				}
+			}
+		else
+			{
+			// Restore SMTP settings from the service supplied.
+			iMsvEntry->SetEntryL(iSmtpServiceId);
+			RestoreSmtpSettingsL();
+			}
+		}
+	else if( iMsgType == KUidMsgTypePCMail )
+		{
+		if( iOperation == EReply )
+			{
+			// reply via the same service as the original message
+			iMsvEntry->SetEntryL(iOrigMessageId);
+			iPCMailServiceId = iMsvEntry->Entry().iServiceId;
+			}
+		else if( iSmtpServiceId != KMsvNullIndexEntryId ) // iSmtpService may hold the PCMail Service Id!
+			iPCMailServiceId = iSmtpServiceId;
+		else
+			iPCMailServiceId = KMsvUnknownServiceIndexEntryId;
+		}
+	iNewHeader = CImHeader::NewLC();
+	CleanupStack::Pop(iNewHeader);
+	iEmailMessage = CImEmailMessage::NewL(*iMsvEntry);
+	iParaLayer = CParaFormatLayer::NewL();
+	iCharLayer = CCharFormatLayer::NewL();
+	iRichText = CRichText::NewL(iParaLayer, iCharLayer);
+	iAttachmentInfoList.ResetAndDestroy();
+	if( iOrigMessageId != KMsvNullIndexEntryId )
+		{
+		iMsvEntry->SetEntryL(iOrigMessageId);
+		iOrigMessageHtml = static_cast<TMsvEmailEntry>(iMsvEntry->Entry()).MHTMLEmail();
+		}
+	if( iMsvEmailTypeList & KMsvEmailTypeListMHTMLMessage )
+		{
+		TRAPD(err, iHtmlConverter = CImHtmlConverter::NewL(*iMsvEntry, *iParaLayer, *iCharLayer));
+		if( err != KErrNone )
+			{
+			if( err == KErrNoMemory )
+				User::Leave(KErrNoMemory);
+			else
+				gPanic(EImcmHtmlConverterNotFound);
+			}
+		iCreateHtmlMessage = ETrue;
+		}
+	if( iMsgType == KUidMsgTypeSMTP && iOperation != ECopy )
+		CheckForSignatureOrVCardL();
+	if( iNeedToAddVCardAttachment || iCreateHtmlMessage || (iOperation!=ENew && iOperation!=ECopy) )
+		OpenAndReadResourceFileL();
+	CActiveScheduler::Add(this);
+	// The signature needs to be added to the richtext regardless of whether the
+	// body is included iSignatureText will only be set if the Signature flag is
+	// set in the SMTP settings and if there is a richtext stream.
+	if( iSignatureText )
+		iRichText->AppendTakingSolePictureOwnershipL(*iSignatureText);
+	if( iOperation == ENew )
+		iState = ECreateNewMessageEntry;
+	ProcessStateL();
+	iObserverRequestStatus = KRequestPending;
+	SetActive();
+	}
+void CImEmailOperation::OpenAndReadResourceFileL()
+	{
+	RResourceFile resourceFile;
+	OpenResourceFileL(resourceFile, iMsvSession.FileSession());
+	CleanupClosePushL(resourceFile);
+	HBufC8* buf;
+	TResourceReader reader;
+	if( iFormatString == NULL )
+		{
+		if( (iOperation == EForward) || (iOperation == EForwardAsAttachment) )
+			{
+			buf = resourceFile.AllocReadLC(FORWARD_FORMATTING_STRING);
+			reader.SetBuffer(buf);
+			iFormatString = (reader.ReadTPtrC()).AllocL();
+			CleanupStack::PopAndDestroy(buf);
+			}
+		else if( iOperation == EReply )
+			{
+			buf = resourceFile.AllocReadLC(REPLY_FORMATTING_STRING);
+			reader.SetBuffer(buf);
+			iFormatString = (reader.ReadTPtrC()).AllocL();
+			CleanupStack::PopAndDestroy(buf);
+			}
+		else if( iOperation == EReceipt )
+			{
+			buf = resourceFile.AllocReadLC(RECEIPT_FORMATTING_STRING);
+			reader.SetBuffer(buf);
+			iFormatString = (reader.ReadTPtrC()).AllocL();
+			CleanupStack::PopAndDestroy(buf);
+			}
+		}
+	if( (iOperation == EForward) || (iOperation == EForwardAsAttachment) || (iOperation == EReply) )
+		{
+		RestoreOriginalHeaderL();
+		TInt format;
+		if( (iOperation == EForward) || (iOperation == EForwardAsAttachment) )
+			{
+			switch (iBodyHeaderFormat)
+				{
+				case EToAndCc:
+					format = FORWARD_BODY_HEADER_TOCC;
+					break;
+				case EToOnly:
+					format = FORWARD_BODY_HEADER_TOONLY;
+					break;
+				case ECcOnly:
+					format = FORWARD_BODY_HEADER_CCONLY;
+					break;
+				case ENoToCcInfo:
+				default:
+					format = FORWARD_BODY_HEADER;
+					break;
+				}
+			}
+		else  // iOperation == EReply
+			{
+			switch (iBodyHeaderFormat)
+				{
+				case EToAndCc:
+					format = REPLY_BODY_HEADER_TOCC;
+					break;
+				case EToOnly:
+					format = REPLY_BODY_HEADER_TOONLY;
+					break;
+				case ECcOnly:
+					format = REPLY_BODY_HEADER_CCONLY;
+					break;
+				case ENoToCcInfo:
+				default:
+					format = REPLY_BODY_HEADER;
+					break;
+				}
+			}
+		buf = resourceFile.AllocReadLC(format);
+		reader.SetBuffer(buf);
+		iBodyHeaderFormatString = (reader.ReadTPtrC()).AllocL();
+		CleanupStack::PopAndDestroy(buf);
+		buf = resourceFile.AllocReadLC(BODY_HEADER_DATETIME_FORMAT);
+		reader.SetBuffer(buf);
+		iBodyHeaderDateTimeFormatString = (reader.ReadTPtrC()).AllocL();
+		CleanupStack::PopAndDestroy(buf);
+		}
+	if( iNeedToAddVCardAttachment )
+		{
+		buf = resourceFile.AllocReadLC(DEFAULT_VCARD_NAME);
+		reader.SetBuffer(buf);
+		iDefaultVCardNameFormatString = (reader.ReadTPtrC()).AllocL();
+		CleanupStack::PopAndDestroy(buf);
+		}
+	if( iHtmlConverter != NULL )
+		iHtmlConverter->ReadDefaultAttachmentNameL(resourceFile);
+	CleanupStack::PopAndDestroy(&resourceFile);
+	}
+void CImEmailOperation::SetSmtpServiceFromDefaultsL()
+	{
+	// Get the default SMTP service Id from CenRep
+	CEmailAccounts* account = CEmailAccounts::NewLC();
+	TSmtpAccount id;
+	TInt error = account->DefaultSmtpAccountL(id);
+	CleanupStack::PopAndDestroy(account);
+	if (error == KErrNone)
+		{
+		iSmtpServiceId = id.iSmtpService;
+		iMsvEntry->SetEntryL(iSmtpServiceId);
+		RestoreSmtpSettingsL();
+		}
+	else if (error == KErrNotFound)
+		{
+		iSmtpServiceId = KMsvUnknownServiceIndexEntryId;
+		}
+	}
+void CImEmailOperation::SetSmtpServiceFromOriginalMessageL()
+	{
+	__ASSERT_DEBUG( iOperation != ENew, User::Invariant() );
+	iMsvEntry->SetEntryL(iOrigMessageId);
+	__ASSERT_DEBUG(iMsvEntry->Entry().iServiceId != KMsvLocalServiceIndexEntryIdValue, gPanic(EMiutLocalServiceIdSet));
+	// Get iServiceId from original message and then move context to the service
+	// (e.g. POP).
+	iSmtpServiceId = iMsvEntry->Entry().iServiceId;
+	iMsvEntry->SetEntryL(iMsvEntry->Entry().iServiceId);
+	// Now move context to SMTP to access the SMTP settings.
+	iSmtpServiceId = iMsvEntry->Entry().iRelatedId;
+	iMsvEntry->SetEntryL(iSmtpServiceId);
+	RestoreSmtpSettingsL();
+	}
+void CImEmailOperation::RestoreSmtpSettingsL()
+	{
+	CEmailAccounts* account = CEmailAccounts::NewLC();
+	TSmtpAccount id;
+	account->GetSmtpAccountL(iMsvEntry->Entry().Id(), id);
+	account->LoadSmtpSettingsL(id, *iSmtpSettings);
+	CleanupStack::PopAndDestroy(account);
+	}
+void CImEmailOperation::ErrorRecovery(TInt error)
+	{
+	if (iNewMessageId!=KMsvNullIndexEntryId)
+		iMsvEntry->Session().RemoveEntry(iNewMessageId);
+	// complete the observer with error
+	TRequestStatus* status=&iObserverRequestStatus;
+	User::RequestComplete(status,error);
+	}
+void CImEmailOperation::SelectNextStateL()
+	{
+	switch( iState )
+		{
+	case ECreateNewHeader:
+		{
+		if( iOperation & EAttachOriginal )
+			iState = ECreateNewMessageEntry;
+		else if( iPartList & KMsvMessagePartBody )
+			iState = EGetBodyText;
+		else if( iPartList & KMsvMessagePartAttachments )
+			iState = EGetAttachmentList;
+		else
+			iState = EGetMessageDigest;
+		} break;
+	case EGetBodyText:
+		{
+		// This may be an HTML message with no text alternative to the HTML if
+		// there is no body text.
+		TInt sizeOfBody = 0;
+		TBool isPlainText = EFalse;
+		iEmailMessage->GetBodyTextEntryIdL(iOrigMessageId,CImEmailMessage::EThisMessageOnly);
+		// Check if the original message was stored as plain text or rich text.
+		if( iEmailMessage->Selection().Count() )
+			{
+			TMsvId textId = iEmailMessage->Selection().At(0);
+			iMsvEntry->SetEntryL(textId);
+			CMsvStore* store = iMsvEntry->ReadStoreL();
+			CleanupStack::PushL(store);
+			isPlainText = (store->IsPresentL(KMsvPlainBodyText16) || store->IsPresentL(KMsvPlainBodyText8));
+			CleanupStack::PopAndDestroy(store);
+			store = NULL;
+			}
+		// The body text is not in richtext format, so don't populate it.
+		if(isPlainText)
+			{
+			// Find out the size of the body text.
+			sizeOfBody = GetPlainBodyTextSizeL();
+			}
+		else
+			{
+			sizeOfBody = iRichText->DocumentLength();
+			sizeOfBody = sizeOfBody * 2;
+			}
+		if( iOrigMessageHtml && (((sizeOfBody) - iRichTextSize) == 0) )
+			iHtmlNoTextAlt = ETrue;
+		if( iPartList & KMsvMessagePartAttachments )
+			iState = EGetAttachmentList;
+		else
+			iState = EGetMessageDigest;
+		} break;
+	case EGetAttachmentList:
+		{
+		// Need a copy of attachment list as the CImEmailMessage object may be reset
+		TInt count = iEmailMessage->AttachmentManager().AttachmentCount();
+		for(TInt index = 0; index < count ; index++)
+			{
+			CMsvAttachment* attachment = CMsvAttachment::NewL(*iEmailMessage->AttachmentInfoSelection()[index]);
+			CleanupStack::PushL(attachment);
+			User::LeaveIfError(iAttachmentInfoList.Append(attachment));
+			CleanupStack::Pop(attachment);
+			}
+		iState = EGetMessageDigest;
+		} break;
+	case EGetMessageDigest:
+		{
+		iEmbeddedMessagesToProcess = iEmailMessage->Selection().Count();
+		iState = ECreateNewMessageEntry;
+		} break;
+	case ECreateNewMessageEntry:
+		{
+		iNewMessageId = McliUtils::GetProgressIdL(*iMsvOperation);
+		iState = ECheckMultipartMixedFolderRequired;
+		} break;
+	case ECheckMultipartMixedFolderRequired:
+		{
+		if(	NeedMultipartMixedFolder() )
+			iState = ECreateMultipartMixedFolderEntry;
+		else
+			iState = ECheckMultipartAlternativeFolderRequired;
+		} break;
+	case ECreateMultipartMixedFolderEntry:
+		{
+		iMultipartMixedFolderCreated = ETrue;
+		iMultipartMixedId = McliUtils::GetProgressIdL(*iMsvOperation);
+		iState = ECheckMultipartAlternativeFolderRequired;
+		} break;
+	case ECheckMultipartAlternativeFolderRequired:
+		{
+		if( iCreateHtmlMessage )
+			iState = ECreateMultipartAlternativeFolderEntry;
+		else
+			iState = ECheckTextEntryRequired;
+		} break;
+	case ECreateMultipartAlternativeFolderEntry:
+		{
+		iMultipartAlternativeFolderCreated = ETrue;
+		iMultipartAlternativeId = McliUtils::GetProgressIdL(*iMsvOperation);
+		iState = ECheckTextEntryRequired;
+		} break;
+	case ECheckTextEntryRequired:
+		{
+		if( (iMultipartMixedFolderCreated && ((iPartList & KMsvMessagePartBody) || iNeedToAddVCardAttachment || iSignatureText )) ||
+			(iMultipartAlternativeFolderCreated) ||
+			(iPartList & KMsvMessagePartBody) ||
+			((iPartList & KMsvMessagePartAttachments) && iOperation != ECopy && iTotalAttachments == 0) ||
+			(!(iPartList & KMsvMessagePartAttachments) && !(iPartList & KMsvMessagePartBody) && !iNeedToAddVCardAttachment && !iCreateHtmlMessage) )
+			{
+			// Hmmm, quite a convaluted way of working out if a text entry is needed!!
+			iState = ECreateTextEntry;
+			}
+		else
+			iState = ECheckVCardRequired;
+		} break;
+	case ECreateTextEntry:
+		{
+		iTextId = McliUtils::GetProgressIdL(*iMsvOperation);
+		if( (iPartList & KMsvMessagePartBody && !(iOperation & EAttachOriginal)) || iSignatureText )
+			iState = EStoreBody;
+		else
+			iState = ECheckVCardRequired;
+		} break;
+	case EStoreBody:
+		{
+		iState = ECheckVCardRequired;
+		} break;
+	case ECheckVCardRequired:
+		{
+		if( iNeedToAddVCardAttachment && (iOperation != ECopy) )
+			iState = ECreateVCardAttachment;
+		else
+			iState = ECheckHTMLEntryRequired;
+		} break;
+	case ECreateVCardAttachment:
+		{
+		iVcardId = McliUtils::GetProgressIdL(*iMsvOperation);
+		iState = EAddVCardAttachment;
+		} break;
+	case EAddVCardAttachment:
+		{
+		iState = ECheckHTMLEntryRequired;
+		} break;
+	case ECheckHTMLEntryRequired:
+		{
+		if( iCreateHtmlMessage )
+			iState = ECreateHTMLEntry;
+		else
+			iState = ECheckAttachOriginalMessageRequired;
+		} break;
+	case ECreateHTMLEntry:
+		{
+		__ASSERT_DEBUG( iMultipartAlternativeFolderCreated, User::Invariant() );
+		iHtmlId = McliUtils::GetProgressIdL(*iMsvOperation);
+		TMsvId serviceId;
+		TMsvEmailEntry textEntry;
+		iMsvEntry->Session().GetEntry(iTextId, serviceId, textEntry);
+		// Store character set info in a MimeHeader.
+		iMsvEntry->SetEntryL(iHtmlId);
+		iState = ECreateDefaultHtmlAttachment;
+		iStore = iMsvEntry->EditStoreL();
+		} break;
+	case ECreateDefaultHtmlAttachment:
+		{
+		CImMimeHeader* mimeHeader = CImMimeHeader::NewLC();
+		mimeHeader->SetMimeCharset(KCharacterSetIdentifierUtf8);
+		mimeHeader->StoreL(*iStore);
+		iStore->CommitL();
+		CleanupStack::PopAndDestroy(mimeHeader);
+		iFile.Close();
+		delete iStore;
+		iStore=NULL;
+		TMsvId serviceId;
+		TMsvEmailEntry textEntry;
+		iMsvEntry->Session().GetEntry(iTextId, serviceId, textEntry);
+		iMsvEntry->SetEntryL(iMultipartAlternativeId);
+		if( iPartList & KMsvMessagePartBody && (textEntry.iSize > 0) && !(iOperation & EAttachOriginal) )
+			iState = EPrepareToStoreHTMLEntryText;
+		else
+			iState = ECheckAttachOriginalMessageRequired;
+		}break;
+	case EPrepareToStoreHTMLEntryText:
+		{
+		iFinishedConvertingHTML = EFalse;
+		if(iUsePlainTextStorage && iRestoreErr == KErrNoMemory)
+			{
+			// If iRestoreErr is KErrNoMemory then complete the store message operation.
+			iState = ECompleteEmailOperation;
+			}
+		else
+			{
+			if( iHtmlId != KMsvNullIndexEntryId )
+				iState = EStoreHTMLEntryText;
+			else
+				iState = ECheckAttachOriginalMessageRequired;
+			}
+		} break;
+	case EStoreHTMLEntryText:
+		{
+		if( iFinishedConvertingHTML )
+			{
+			iHtmlConverter->ResetStoreL();
+			iState = EStoreHTMLTextInEntry;
+			}
+		// Otherwise stay in this state until the HTML has been converted.
+		} break;
+	case EStoreHTMLTextInEntry:
+		iState = ECheckAttachOriginalMessageRequired;
+		break;
+	case EAddMessageAttachmentInfo:
+		{
+		ResetStoreL();
+		iState = ECompleteEmailOperation;
+		}break;
+	case ECheckAttachOriginalMessageRequired:
+		{
+		if( (iOperation & EAttachOriginal) && (iPartList & KMsvMessagePartBody || iPartList & KMsvMessagePartAttachments) )
+			iState = EAttachOriginalMessage;
+		else
+			iState = ECheckHTMLPageRequired;
+		} break;
+	case EAttachOriginalMessage:
+		{
+		TPckgBuf<TMsvId> paramPack;
+		paramPack.Copy(iMsvOperation->FinalProgress());
+		iAttachedMessageId = paramPack();
+		iMsvEntry->SetEntryL(iAttachedMessageId);
+		iState = EAddMessageAttachmentInfo;
+		} break;
+	case ECheckHTMLPageRequired:
+		{
+		TInt sizeOfBody = 0;
+		if(iUsePlainTextStorage && iOperation != ENew)
+			{
+			iEmailMessage->GetBodyTextEntryIdL(iNewMessageId, CImEmailMessage::EThisMessageOnly);
+			sizeOfBody = GetPlainBodyTextSizeL();
+			}
+		else
+			{
+			sizeOfBody = iRichText->DocumentLength();
+			sizeOfBody = sizeOfBody * 2;
+			}
+		if( iPartList & KMsvMessagePartBody && iOrigMessageHtml &&
+			(iOperation != ENew) &&	(((sizeOfBody) - iRichTextSize) == 0) )
+			iState = EFindHTMLPage;
+		else
+			iState = ECheckAttachmentsRequired;
+		} break;
+	case EFindHTMLPage:
+		{
+		iState = ECopyHTMLPartToAttachment;
+		} break;
+	case ECopyHTMLPartToAttachment:
+		{
+		iState = ECheckAttachmentsRequired;
+		} break;
+	case ECheckAttachmentsRequired:
+		{
+		if( iPartList & KMsvMessagePartAttachments && (iTotalAttachments > 0) && (iOperation != ENew) )
+			{
+			iFileMan = CFileMan::NewL(iMsvSession.FileSession());
+			iState = ECreateAttachmentEntry;
+			}
+		else
+			iState = ECheckEmbeddedMessagesRequired;
+		} break;
+	case ECreateAttachmentEntry:
+		{
+		iState = EStoreAttachment;
+		} break;
+	case EStoreAttachment:
+		{
+		ResetStoreL();
+		//	Are there more attachments to be added?
+		if( ++iAttachmentCount < iTotalAttachments )
+			iState = ECreateAttachmentEntry;
+		else
+			iState = ECheckEmbeddedMessagesRequired;
+		} break;
+	case ECheckEmbeddedMessagesRequired:
+		{
+		if( iEmbeddedMessagesToProcess > 0 )
+			iState = EAddEmbeddedMessagesAsAttachments;
+		else
+			iState = ECompleteEmailOperation;
+		} break;
+	case EAddEmbeddedMessagesAsAttachments:
+		{
+		if(iEmbeddedMessagesToProcess > 0)
+			{
+			iState = EAddEmbeddedMessagesAsAttachments;
+			}
+		else
+			{
+			iState = ECompleteEmailOperation;
+			}
+		} break;
+	case ECompleteEmailOperation:
+		{
+		iState = EFinished;
+		} break;
+	default:
+		__ASSERT_DEBUG( EFalse, User::Invariant() );
+		break;
+		}
+	}
+void CImEmailOperation::ProcessStateL()
+	{
+	CMsvOperation* op = NULL;
+	switch( iState )
+		{
+	case ECreateNewHeader:
+		{
+		CreateNewHeaderL();
+		} break;
+	case EGetBodyText:
+		{
+		GetBodyTextL();
+		} break;
+	case EGetAttachmentList:
+		{
+		iEmailMessage->GetAttachmentsListL(iStatus, iOrigMessageId, CImEmailMessage::EAllAttachments, CImEmailMessage::EThisMessageOnly);
+		} break;
+	case EGetMessageDigest:
+		{
+		iEmailMessage->GetMessageDigestEntriesL(iStatus, iOrigMessageId);
+		} break;
+	case ECreateNewMessageEntry:
+		{
+		CreateNewMessageL(iDestinationId);
+		} break;
+	case ECreateMultipartMixedFolderEntry:
+		{
+		CreateMultipartMixedFolderEntryL();
+		} break;
+	case ECreateMultipartAlternativeFolderEntry:
+		{
+		CreateMultipartAlternativeFolderEntryL();
+		} break;
+	case ECreateTextEntry:
+		{
+		if (iMultipartAlternativeFolderCreated)
+			CreateTextEntryL(iMultipartAlternativeId);
+		else if (iMultipartMixedFolderCreated)
+			CreateTextEntryL(iMultipartMixedId);
+		else
+			CreateTextEntryL(iNewMessageId);
+		} break;
+	case EStoreBody:
+		{
+		StoreBodyL();
+		} break;
+	case ECreateVCardAttachment:
+		{
+		CreateVCardAttachmentL();
+		} break;
+	case EAddVCardAttachment:
+		{
+		AddVCardAttachmentL();
+		} break;
+	case ECreateHTMLEntry:
+		{
+		CreateHTMLEntryL();
+		} break;
+	case EPrepareToStoreHTMLEntryText:
+		{
+		TRAP(iRestoreErr ,iHtmlConverter->PrepareToStoreHTMLEntryTextL(iHtmlId, iTextId));
+		// Do not leave if it is KErrNoMemory while creating HTML part for a message, since the
+		// plainbody text part of message is already created and that be used to send the message.
+		if(iUsePlainTextStorage)
+			{
+			if(iRestoreErr != KErrNoMemory)
+				{
+				User::LeaveIfError(iRestoreErr);
+				}
+			}
+		else
+			{
+			User::LeaveIfError(iRestoreErr);
+			}
+		RequestComplete(KErrNone);
+		} break;
+	case EStoreHTMLEntryText:
+		{
+		iFinishedConvertingHTML = iHtmlConverter->StoreHTMLEntryTextAL(iStatus);
+		if(!iFinishedConvertingHTML)
+			RequestComplete(KErrNone);
+		else
+			{
+			iVCardAndHtmlSize += iHtmlConverter->Size();
+			}
+		} break;
+	case ECreateDefaultHtmlAttachment:
+		{
+		CreateDefaultAttachmentL();
+		}break;
+	case EStoreHTMLTextInEntry:
+		op = iHtmlConverter->ChangeHTMLTextInEnrtyL(iStatus);
+		if(!op)
+			RequestComplete(KErrNone);
+		else
+			{
+			delete iMsvOperation;
+			iMsvOperation = op;
+			}
+		break;
+	case EAddMessageAttachmentInfo:
+		{
+		AddMessageAttachmentInfoL(iAttachedMessageId);
+		} break;
+	case EAttachOriginalMessage:
+		{
+		AttachOriginalMessageToNewMessageL();
+		} break;
+	case EFindHTMLPage:
+		{
+		iEmailMessage->FindFirstHTMLPageL(iOrigMessageId, iStatus);
+		} break;
+	case ECopyHTMLPartToAttachment:
+		{
+		AppendHtmlAttachmentL();
+		} break;
+	case ECreateAttachmentEntry:
+		{
+		CreateAttachmentEntryL();
+		} break;
+	case EStoreAttachment:
+		{
+		StoreAttachmentL();
+		} break;
+	case EAddEmbeddedMessagesAsAttachments:
+		{
+		AddMessageAsAttachmentL();
+		} break;
+	case ECompleteEmailOperation:
+		{
+		CompleteEmailOperationL();
+		} break;
+	case EFinished:
+		{
+		TRequestStatus* status=&iObserverRequestStatus;
+		User::RequestComplete(status,KErrNone);
+		} break;
+	case ECheckMultipartMixedFolderRequired:
+	case ECheckMultipartAlternativeFolderRequired:
+	case ECheckTextEntryRequired:
+	case ECheckVCardRequired:
+	case ECheckHTMLEntryRequired:
+	case ECheckAttachOriginalMessageRequired:
+	case ECheckHTMLPageRequired:
+	case ECheckAttachmentsRequired:
+	case ECheckEmbeddedMessagesRequired:
+		{
+		RequestComplete(KErrNone);
+		} break;
+	default:
+		__ASSERT_DEBUG( EFalse, User::Invariant() );
+		break;
+		}
+	}
+void CImEmailOperation::RequestComplete(TInt aError)
+	{
+	iStatus = KRequestPending;
+	TRequestStatus* status=&iStatus;
+	iStatus=KRequestPending;
+	User::RequestComplete(status,aError);
+	}
+TMsvId CImEmailOperation::ServiceId()
+	{
+	// this functions returns the correct service id dependant on the Message Type.
+	if (iMsgType == KUidMsgTypePCMail)
+		return iPCMailServiceId;
+	return iSmtpServiceId;
+	}
+void CImEmailOperation::CreateNewHeaderL()
+	{
+	//	1.	Create new header using the original message.
+	//	2.	Change header details depending on the operation required.
+	//	3.	Create the body header now since we have the original message
+	if (iOriginalHeader==NULL)
+		{
+		RestoreOriginalHeaderL();
+		}
+	switch( iOperation )
+		{
+	case EForward:
+	case EForwardAsAttachment:
+		{
+		iOriginalHeader->CreateForwardL(*iNewHeader, *iFormatString);
+		} break;
+	case EReply:
+		{
+		if( (iPartList & KMsvMessagePartOriginator) && !(iPartList & KMsvMessagePartRecipient) )
+			iOriginalHeader->CreateReplyL(*iNewHeader, CImHeader::EOriginator, *iFormatString);
+		else
+			{
+			if( (iPartList & KMsvMessagePartOriginator) && (iPartList & KMsvMessagePartRecipient) )
+				iOriginalHeader->CreateReplyL(*iNewHeader, CImHeader::EAll, *iFormatString);
+			else
+				iOriginalHeader->CreateReplyL(*iNewHeader, CImHeader::ERecipients, *iFormatString);
+			// Remove the user's email address (if provisioned) from the To: and Cc: headers
+			// of the reply message.  But ensure there is at least one email
+			// address in the To: header to account for the scenario when the
+			// user may be replying to a message they sent themselves.
+			if (iSmtpSettings->EmailAddress().Length())
+				{
+				TInt i = 0;
+				while (i < iNewHeader->ToRecipients().Count())
+					{
+					if ((iNewHeader->ToRecipients().Count() > 1) && (iNewHeader->ToRecipients()[i]).FindF(iSmtpSettings->EmailAddress()) >= 0)
+						// Only delete if there is more than one recipient because we do
+						// not want to create a reply with an empty To: header.
+						iNewHeader->ToRecipients().Delete(i);
+					else
+						++i;
+					}
+				i = 0;
+				while (i < iNewHeader->CcRecipients().Count())
+					{
+					if ((iNewHeader->CcRecipients()[i]).FindF(iSmtpSettings->EmailAddress()) >= 0)
+						iNewHeader->CcRecipients().Delete(i);
+					else
+						++i;
+					}
+				}
+			}
+		} break;
+	case ECopy:
+		{
+		delete iNewHeader;
+		iNewHeader = iOriginalHeader;
+		} break;
+	case EReceipt:
+		{
+		iOriginalHeader->CreateReceiptL(*iNewHeader, *iFormatString);
+		} break;
+	default:
+		__ASSERT_DEBUG( EFalse, User::Invariant() );
+		break;
+		}
+	if (iPartList & !KMsvMessagePartDescription)
+		iNewHeader->SetSubjectL(KNullDesC);
+	if ((iBodyHeaderFormatString != NULL ) && (iBodyHeaderFormatString->Find(KMiutFormatString)))
+		{
+		__ASSERT_DEBUG(iBodyHeaderDateTimeFormatString!=NULL, User::Invariant());
+		TTime date = iMsvEntry->Entry().iDate;
+		//Convert time to local time.
+		RTz myTZoneServer;
+		// Connect to the time zone server, leaves if fails to connect
+		User::LeaveIfError(myTZoneServer.Connect());
+		CleanupClosePushL(myTZoneServer);
+		// Create a converter object.
+		CTzConverter* myConverter = CTzConverter::NewL(myTZoneServer);
+		CleanupStack::PushL(myConverter);
+		myConverter->ConvertToLocalTime(date);
+		CleanupStack::PopAndDestroy(2);  //myTZoneServer,myConverter
+		TBuf<KMaxLongDateFormatSpec+KMaxTimeFormatSpec+1> parsedDateTime;
+	        date.FormatL(parsedDateTime, *iBodyHeaderDateTimeFormatString);
+		// Numberconvertion to the local phone language
+		TLocale localeInfo;
+		localeInfo.Refresh();
+		TDigitType dgType = localeInfo.DigitType();
+		NumberConversion::ConvertDigits(parsedDateTime, dgType);
+		TPtrC subject = iOriginalHeader->Subject();
+		TPtrC author = iOriginalHeader->From();
+		iOriginalHeader = NULL;
+		switch (iBodyHeaderFormat)
+			{
+			case EToAndCc:
+				{
+				iBodyHeader = HBufC::NewL(subject.Length() + author.Length() + parsedDateTime.Length() + iBodyHeaderToString->Length() + iBodyHeaderCcString->Length() + iBodyHeaderFormatString->Length());
+				TPtr bodyHeaderPtr = iBodyHeader->Des();
+				bodyHeaderPtr.Format(TRefByValue<const TDesC>(*iBodyHeaderFormatString), &subject, &author, iBodyHeaderToString, iBodyHeaderCcString, &parsedDateTime);
+				} break;
+			case EToOnly:
+				{
+				iBodyHeader = HBufC::NewL(subject.Length() + author.Length() + parsedDateTime.Length() + iBodyHeaderToString->Length() + iBodyHeaderFormatString->Length());
+				TPtr bodyHeaderPtr = iBodyHeader->Des();
+				bodyHeaderPtr.Format(TRefByValue<const TDesC>(*iBodyHeaderFormatString), &subject, &author, iBodyHeaderToString, &parsedDateTime);
+				} break;
+			case ECcOnly:
+				{
+				iBodyHeader = HBufC::NewL(subject.Length() + author.Length() + parsedDateTime.Length() + iBodyHeaderCcString->Length() + iBodyHeaderFormatString->Length());
+				TPtr bodyHeaderPtr = iBodyHeader->Des();
+				bodyHeaderPtr.Format(TRefByValue<const TDesC>(*iBodyHeaderFormatString), &subject, &author, iBodyHeaderCcString, &parsedDateTime);
+				} break;
+			case ENoToCcInfo:
+			default:
+				{
+				iBodyHeader = HBufC::NewL(subject.Length() + author.Length() + parsedDateTime.Length() + iBodyHeaderFormatString->Length());
+				TPtr bodyHeaderPtr = iBodyHeader->Des();
+				bodyHeaderPtr.Format(TRefByValue<const TDesC>(*iBodyHeaderFormatString), &subject, &author, &parsedDateTime);
+				}
+			} // switch (iBodyHeaderFormat)
+		}
+	RequestComplete(KErrNone);
+	}
+void CImEmailOperation::RestoreOriginalHeaderL()
+	{
+	__ASSERT_DEBUG(iOriginalHeader==NULL, User::Invariant());
+	iOriginalHeader = CImHeader::NewLC();
+	CleanupStack::Pop(iOriginalHeader);
+	// Restore the header from the original message.
+	iMsvEntry->SetEntryL(iOrigMessageId);
+	CMsvStore* store = iMsvEntry->ReadStoreL();
+	CleanupStack::PushL(store);
+	iOriginalHeader->RestoreL(*store);
+	CleanupStack::PopAndDestroy(store);
+	SetBodyHeaderFormatL();
+	}
+void CImEmailOperation::SetBodyHeaderFormatL()
+	{
+	// determine if To: and CC: fields are to be included in reply/forwarded email
+	// body header. If so, prepare the string to be included.
+	if (iSmtpSettings->ToCcIncludeLimit() > 0)
+		{
+		if (iOriginalHeader->ToRecipients().Count()>0)
+			{
+			if (iOriginalHeader->CcRecipients().Count()>0)
+				{
+				iBodyHeaderFormat=EToAndCc;
+				CreateAddressListStringL(iBodyHeaderCcString, iOriginalHeader->CcRecipients());
+				}
+			else
+				{
+				iBodyHeaderFormat=EToOnly;
+				}
+			CreateAddressListStringL(iBodyHeaderToString, iOriginalHeader->ToRecipients());
+			}
+		else // no "to" recipients, any "cc"?
+			{
+			if (iOriginalHeader->CcRecipients().Count()>0)
+				{
+				iBodyHeaderFormat=ECcOnly;
+				CreateAddressListStringL(iBodyHeaderCcString, iOriginalHeader->CcRecipients());
+				}
+			else
+				{
+				iBodyHeaderFormat=ENoToCcInfo;
+				}
+			}
+		}
+	else
+		{
+		iBodyHeaderFormat=ENoToCcInfo;
+		}
+	}
+void CImEmailOperation::CreateAddressListStringL(HBufC*& aListBuffer, const CDesCArray& aAddressArray)
+	{
+	// Prepares a list of addresses to include in body header of reply/forwarded emails,
+	// truncated if exceeding the set limit.
+	// The original data may be either an array of individual addresses, or a single
+	// descriptor containing multiple comma separated addresses.
+	TBool truncate=EFalse;
+	TInt  length=0;
+	TInt  count=0;
+	TInt  limit=iSmtpSettings->ToCcIncludeLimit();
+	TInt  elements=aAddressArray.Count();
+	if (elements==0)
+		return;
+	if (elements==1) // handle single string containing one or more addresses
+		{
+		// truncate the string if necessary
+		TInt lastChar=0;
+		truncate=iMessageField.TruncateAddressString(aAddressArray[0], limit, lastChar);
+		if (!truncate)
+			{
+			aListBuffer = HBufC::NewL(aAddressArray[0].Length());
+			TPtr addrStringPtr = aListBuffer->Des();
+			addrStringPtr.Append(aAddressArray[0]);
+			}
+		else
+			{
+			aListBuffer = HBufC::NewL(lastChar+KEllipsesString.iTypeLength); // room for the truncated list + ellipses
+			TPtr addrStringPtr = aListBuffer->Des();
+			TPtrC16 leftString=aAddressArray[0].Left(lastChar);
+			TInt temp1 = leftString.Length();
+			TInt temp2 = aListBuffer->Length();
+			addrStringPtr.Append(leftString);
+			addrStringPtr.Append(KEllipsesString);
+			}
+		}
+	else	// handle array of individual addresses.
+		{
+		// determine if list to be truncated
+		if (limit<elements)
+			{
+			count=limit;
+			truncate=ETrue;
+			}
+		else
+			{
+			count=elements;
+			}
+		// calculate length required for the address string
+		TInt n;
+		for (n=0;n<count-1;++n)
+			{
+			length+=aAddressArray[n].Length()+KSeparatorString.iTypeLength;
+			}
+		length+=aAddressArray[n].Length();
+		if (truncate)
+			{
+			length+=KEllipsesString.iTypeLength;
+			}
+		delete aListBuffer;
+		aListBuffer = NULL;
+		aListBuffer = HBufC::NewL(length);
+		TPtr addrStringPtr = aListBuffer->Des();
+		// populate the address buffer
+		for (n=0;n<count-1;++n)
+			{
+			addrStringPtr.Append(aAddressArray[n]);
+			addrStringPtr.Append(KSeparatorString);
+			}
+		addrStringPtr.Append(aAddressArray[n]);
+		if (truncate)
+			{
+			addrStringPtr.Append(KEllipsesString);
+			}
+		}
+	}
+void CImEmailOperation::GetBodyTextL()
+	{
+	//	1.	Insert body header
+	//	2.	Get the Body Text from the original message
+	if (iBodyHeaderFormatString != NULL)
+		iRichText->InsertL(iRichText->DocumentLength(), *iBodyHeader);
+	// DocumentLength() gives no. of chars and since unicode we multiply by 2
+	iRichTextSize = (iRichText->DocumentLength() * 2);
+	iEmailMessage->GetBodyTextEntryIdL(iOrigMessageId,CImEmailMessage::EThisMessageOnly);
+	TMsvId textId = 0;
+	TBool isPlainText = EFalse;
+	// Check if the body text of the message restored here was stored as rich text or not.
+	if( iEmailMessage->Selection().Count() )
+		{
+		textId = iEmailMessage->Selection().At(0);
+		iMsvEntry->SetEntryL(textId);
+		CMsvStore* store = iMsvEntry->ReadStoreL();
+		CleanupStack::PushL(store);
+		// Check if the original message was stored as plain text.
+		if(iUsePlainTextStorage)
+			{
+			isPlainText = (store->IsPresentL(KMsvPlainBodyText16)|| store->IsPresentL(KMsvPlainBodyText8));
+			}
+		CleanupStack::PopAndDestroy(store);
+		store = NULL;
+		}
+	// If the original message was not rich text then need not populate bodytext here.
+	// Body text will be retrieved and stored when StoreBodyL is called .
+	if(isPlainText)
+		{
+		TRequestStatus* myStatus=&iStatus;
+		iStatus=KRequestPending;
+		User::RequestComplete(myStatus,KErrNone);
+		}
+	else
+		{
+		iEmailMessage->GetBodyTextL(iStatus, iOrigMessageId, CImEmailMessage::EThisMessageOnly, *iRichText, *iParaLayer, *iCharLayer);
+		}
+	}
+TInt CImEmailOperation::RemoveIncompleteAttachments()
+	{
+	TInt completeAttachmentCount = 0;
+	while (completeAttachmentCount < iAttachmentInfoList.Count())
+		{
+		if (!(iAttachmentInfoList[completeAttachmentCount]->Complete()))
+			{
+			delete iAttachmentInfoList[completeAttachmentCount];
+			iAttachmentInfoList.Remove(completeAttachmentCount);
+			}
+		else
+			++completeAttachmentCount;
+		}
+	return iAttachmentInfoList.Count();
+	}
+void CImEmailOperation::CreateEntryDetails(TMsvEmailEntry& entry)
+	{
+	entry.iMtm = iMsgType;
+	entry.iServiceId = ServiceId();
+	entry.iType = KUidMsvMessageEntry;
+	entry.iDate.UniversalTime();
+	if ((iOperation != ENew) && (iPartList & KMsvMessagePartAttachments))
+		iTotalAttachments = RemoveIncompleteAttachments();
+	entry.SetNew(ETrue);
+	if (iEmbeddedMessagesToProcess!=0)
+		entry.SetAttachment(ETrue);
+	entry.SetVisible(!(iMsvEmailTypeList & KMsvEmailTypeListInvisibleMessage));
+	entry.SetMHTMLEmail(iCreateHtmlMessage);
+	entry.SetInPreparation(iMsvEmailTypeList & KMsvEmailTypeListMessageInPreparation);
+	}
+void CImEmailOperation::CreateNewMessageL(TMsvId aDestinationId)
+	{
+	//	Create a new message so that the different sections can be added to it:
+	iMsvEntry->SetEntryL(aDestinationId);
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	TMsvEmailEntry entry;
+	CreateEntryDetails(entry);
+	iMsvOperation = iMsvEntry->CreateL(entry, iStatus);
+	}
+TBool CImEmailOperation::NeedMultipartMixedFolder() const
+	{
+	if( (iPartList & KMsvMessagePartAttachments && (iTotalAttachments > 0)) &&
+		(iPartList & KMsvMessagePartBody || iSignatureText || iCreateHtmlMessage || iOperation & EAttachOriginal) )
+		{
+		// In this case the operation is attaching 1 or more attachments. As there
+		// is either message body (signature text implies) or at least another
+		// attachment (HTML body or the original message) then a mixed folder is
+		// needed.
+		return ETrue;
+		}
+	if( iPartList & KMsvMessagePartAttachments && (iTotalAttachments > 0) )
+		{
+		// If this case is reached then although the message body is not required
+		// but it has attachment/s a mixed folder is needed.
+		return ETrue;
+		}
+	if( iOperation & EAttachOriginal && iPartList & KMsvMessagePartBody )
+		{
+		// In this case the operation was attaching the original message as an
+		// attachment (e.g ForwardAsAttachment). As the message body is required
+		// then mixed folder needed.
+		return ETrue;
+		}
+	if( (iNeedToAddVCardAttachment || iHtmlNoTextAlt || iEmbeddedMessagesToProcess) &&
+		(iPartList & KMsvMessagePartBody || iPartList & KMsvMessagePartAttachments))
+		{
+		// A V-card is required or the body text is added as an attachment or
+		// there are embedded messages to attach - all imply an attachment of
+		// some description. As the message body or the attachments are required
+		// then a mixed folder is needed.
+		return ETrue;
+		}
+	if( iNeedToAddVCardAttachment )
+		{
+		//  Now this case is probably not needed - added here because a text
+		// entry is always added. Therefore if defect sorted so that text entry
+		// onlu added when required this case can be removed.
+		return ETrue;
+		}
+	// Got here therefore no mixed folder needed.
+	return EFalse;
+	}
+void CImEmailOperation::CreateMultipartMixedFolderEntryL()
+	{
+	iMsvEntry->SetEntryL(iNewMessageId);
+	TMsvEmailEntry entry;
+	entry.iType = KUidMsvFolderEntry;
+	entry.iMtm = iMsvEntry->Entry().iMtm;
+	entry.iServiceId = iMsvEntry->Entry().iServiceId;
+	entry.SetMessageFolderType(EFolderTypeMixed);
+	entry.iSize = 0;
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	iMsvOperation = iMsvEntry->CreateL(entry, iStatus);
+	}
+void CImEmailOperation::CreateTextEntryL(TMsvId aFolderId)
+	{
+	iMsvEntry->SetEntryL(aFolderId);
+	TMsvEntry entry;
+	entry.iType = KUidMsvEmailTextEntry;
+	entry.iMtm = iMsvEntry->Entry().iMtm;
+	entry.iServiceId = ServiceId();
+	entry.iDate.UniversalTime();
+	entry.iSize = 0;
+	delete iMsvOperation;
+	iMsvOperation=NULL;
+	iMsvOperation=iMsvEntry->CreateL(entry, iStatus);
+	}
+void CImEmailOperation::StoreBodyL()
+	{
+	if(iUsePlainTextStorage)
+		{
+		StorePlainBodyL();
+		return;
+		}
+	iMsvEntry->SetEntryL(iTextId);	//pointing to the text entry
+	CMsvStore* store = iMsvEntry->EditStoreL();
+	CleanupStack::PushL(store);
+	store->StoreBodyTextL(*iRichText);
+	store->CommitL();
+	CleanupStack::PopAndDestroy(store);
+	// update size of text entry
+	TMsvEmailEntry entry(iMsvEntry->Entry());
+	// DocumentLength() gives no. of chars and since unicode, multiply by 2
+	entry.iSize = (iRichText->DocumentLength() * 2);
+	entry.iDate.UniversalTime();
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	iMsvOperation = iMsvEntry->ChangeL(entry, iStatus);
+	}
+void CImEmailOperation::StorePlainBodyL()
+	{
+	TUint charset = 0;
+	TUint defaultCharset = 0;
+	TBool override = EFalse;
+	RFs& fileSvrSession = iMsvSession.FileSession();
+	CCnvCharacterSetConverter* characterConverter = CCnvCharacterSetConverter::NewL();
+	CleanupStack::PushL(characterConverter);
+	CImConvertCharconv* charConv = CImConvertCharconv::NewL(*characterConverter, fileSvrSession);
+	CleanupStack::PushL(charConv);
+	defaultCharset = charConv->SystemDefaultCharset();
+	CleanupStack::PopAndDestroy(2);
+	// To store the ids of all the text part of a email message.
+	RArray<TMsvId> textIdArray;
+	CleanupClosePushL (textIdArray);
+	RPointerArray<CMsvPlainBodyText> plainTextArray;
+	TCleanupItem closePlainTextArray (CImEmailOperation::ClosePlainBodyTextArray, &plainTextArray);
+	CleanupStack::PushL(closePlainTextArray);
+	TInt origSize = 0;
+	// Chunk storage mechanism is used and we are doing a replyto OR fwding a mail then
+	// get the size of the message.
+	if(iOperation == EForward || iOperation == EReply)
+		{
+		iEmailMessage->GetCharacterSetL(iOrigMessageId,charset,override);
+		iEmailMessage->GetBodyTextEntryIdL(iOrigMessageId,CImEmailMessage::EThisMessageOnly);
+		TInt count = iEmailMessage->Selection().Count();
+		for(TInt i=0; i<count; ++i)
+			{
+			User::LeaveIfError (textIdArray.Append( iEmailMessage->Selection().At(i) ));
+			}
+		TInt textIdCount = 	textIdArray.Count();
+		for(TInt i=0; i<textIdCount; ++i)
+			{
+			// Pointing to the text entry.
+			iMsvEntry->SetEntryL(textIdArray[i]);
+			CMsvStore* bodyTextStore = iMsvEntry->ReadStoreL();
+			CleanupStack::PushL(bodyTextStore);
+			plainTextArray.Append( bodyTextStore->InitialisePlainBodyTextForReadL(KMsvDecodeChunkLength));
+			origSize += plainTextArray[i]->Size();
+			CleanupStack::PopAndDestroy(bodyTextStore);
+			bodyTextStore = NULL;
+			}
+		}
+	iMsvEntry->SetEntryL(iTextId);	//pointing to the text entry
+	CMsvStore* bodyTextStore = iMsvEntry->EditStoreL();
+	CleanupStack::PushL(bodyTextStore);
+	// If chunk storage mechanism is used then get CMsvPlainBodyText.
+	// Body text is stored as 16 bit so set iIs8Bit to EFalse.When a message is created from
+	// the client side data is stored as 16 bit.
+	CMsvPlainBodyText* text = bodyTextStore->InitialisePlainBodyTextForWriteL(EFalse,charset,defaultCharset);
+	CleanupStack::PushL(text);
+	// Add signature if it exists.
+	if(iSignatureText)
+		{
+		TInt len = iSignatureText->DocumentLength();
+		HBufC16* signatureText = HBufC16::NewLC(len);
+		TPtr signatureTextPtr = signatureText->Des();
+		iSignatureText->Extract(signatureTextPtr, 0, len);
+		text->StoreChunkL(signatureTextPtr);
+		CleanupStack::PopAndDestroy(signatureText);
+		}
+	if(iBodyHeader)
+		{
+		if(iOperation == EForward || iOperation == EReply)
+			{
+			text->StoreChunkL(iBodyHeader->Des());
+			}
+		}
+	// If email is Fwd'ed or ReplyTo then need to read from the existing mail and add it to
+	// the newly created mail since this was not done in GetBodyTextL.
+	TInt plainTextCount = plainTextArray.Count();
+	for(TInt i=0; i<plainTextCount; ++i)
+		{
+		TInt size = plainTextArray[i]->Size();
+		while( size > 0)
+			{
+			TBuf <KMsvDecodeChunkLength> buf;
+			plainTextArray[i]->NextChunkL(buf);
+			text->StoreChunkL(buf);
+			size -= KMsvDecodeChunkLength;
+			}
+		delete plainTextArray[i];
+		plainTextArray[i] = NULL;
+		}
+	text->CommitL();
+	CleanupStack::PopAndDestroy(4, &textIdArray);// text, bodyTextStore, plainTextArray
+	TMsvEmailEntry entry(iMsvEntry->Entry());
+	entry.iSize = origSize;
+	entry.iDate.UniversalTime();
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	iMsvOperation = iMsvEntry->ChangeL(entry, iStatus);
+	}
+void CImEmailOperation::CheckForSignatureOrVCardL()
+	{
+	if (!iSmtpServiceId || iSmtpServiceId==KMsvUnknownServiceIndexEntryId)
+		return; // No smtp service set.
+	if( iSmtpSettings->AddVCardToEmail() )
+		{
+		CContactDatabase* db = NULL;
+		// check whether the actual VCard exists
+		TRAPD(error, db = CContactDatabase::OpenL());
+		if( error == KErrNone )
+			{
+			CleanupStack::PushL(db);
+			TContactItemId contactId = db->OwnCardId();
+			if( contactId != KNullContactId )
+				iNeedToAddVCardAttachment = ETrue;
+			CleanupStack::PopAndDestroy(db);
+			}
+		else
+			{
+			if( db )
+				delete db;
+			}
+		}
+	if( iSmtpSettings->AddSignatureToEmail() )
+		{
+		// Check the SMTP settings entry for the signature text.
+		iMsvEntry->SetEntryL(iSmtpServiceId);
+		CMsvStore* store = iMsvEntry->ReadStoreL();
+		CleanupStack::PushL(store);
+		if( store->IsPresentL(KMsvEntryRichTextBody) )
+			{
+			iSignatureText=CRichText::NewL(iParaLayer,iCharLayer);
+			store->RestoreBodyTextL(*iSignatureText);
+			}
+		CleanupStack::PopAndDestroy(store);
+		}
+	else
+		iSignatureText=NULL;
+	}
+void CImEmailOperation::CreateVCardAttachmentL()
+	{
+	// Get the vcard from contact database, need owncard entry..
+	CContactDatabase* db = CContactDatabase::OpenL();
+	CleanupStack::PushL(db);
+	TContactItemId contactId = db->OwnCardId();
+	CContactIdArray *ids=CContactIdArray::NewLC();
+	ids->AddL(contactId);
+	if(contactId == KNullContactId)
+		{
+		CleanupStack::PopAndDestroy(2); // db, ids
+		RequestComplete(KErrNone);
+		return; // vcard not present, do nothing.
+		}
+	// Retrieve vcard to a temp store.
+	TUid uid;
+	uid.iUid=KUidVCardConvDefaultImpl;
+	delete iVcardStore;
+	iVcardStore=NULL;
+	iVcardStore=CBufStore::NewL(128);
+	RStoreWriteStream tmpWrite;
+	iVcardStoreId = tmpWrite.CreateLC(*iVcardStore);
+	db->ExportSelectedContactsL(uid,*ids, tmpWrite, CContactDatabase::ETTFormat);
+	tmpWrite.CommitL();
+	iVcardStore->CommitL();
+	// create attachment CMsvEntry entry
+	TBuf<KVCardFilenameLength> textDef;
+	CContactTextDef* contactTextDef = CContactTextDef::NewLC();
+	TLanguage language = User::Language();
+	if( language == ELangTaiwanChinese ||
+		language == ELangHongKongChinese ||
+		language == ELangPrcChinese )
+		{
+		contactTextDef->AppendL(TContactTextDefItem(KUidContactFieldFamilyName));
+		contactTextDef->AppendL(TContactTextDefItem(KUidContactFieldGivenName));
+		}
+	else
+		{
+		contactTextDef->AppendL(TContactTextDefItem(KUidContactFieldGivenName));
+		contactTextDef->AppendL(TContactTextDefItem(KUidContactFieldFamilyName));
+		}
+	contactTextDef->SetExactMatchOnly(ETrue);
+	db->ReadContactTextDefL(contactId,textDef,contactTextDef);
+	CleanupStack::PopAndDestroy(contactTextDef);
+	if (textDef.Length())
+		iFileName.Copy(textDef);
+	else
+		iFileName.Copy(*iDefaultVCardNameFormatString);
+	iFileName.Append(KMimeVCardExtension);
+	if (iMultipartMixedFolderCreated)
+		iMsvEntry->SetEntryL(iMultipartMixedId);
+	else
+		iMsvEntry->SetEntryL(iNewMessageId);
+	CleanupStack::PopAndDestroy(3); // db, ids, tmpWrite,
+	CreateAttachmentEntryL(); //Async
+	}
+void CImEmailOperation::AddVCardAttachmentL()
+	{
+	iMsvEntry->SetEntryL(iVcardId);
+	if (!iFileName.Length())
+		{
+		RequestComplete(KErrNone);
+		return; // ergo no attachment.
+		}
+	// Put vcard into a file.
+	TFileName filePath;
+	CMsvStore* store = iMsvEntry->EditStoreL();
+	CleanupStack::PushL(store);
+	MMsvAttachmentManagerSync& attachmentMgrSync = store->AttachmentManagerExtensionsL();
+	CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
+	RFile file;
+	attachmentMgrSync.CreateAttachmentL(iFileName,file,attachment);
+	store->CommitL();
+	CleanupStack::PopAndDestroy(store);
+	// set the file attachment file handle with write mode
+	iAttachmentFile.SetFileHandle(file,TImAttachmentFile::EImFileWrite);
+	RStoreReadStream dummy;
+	dummy.OpenLC(*iVcardStore,iVcardStoreId);
+	TInt size = (dummy.Source()->SizeL());
+	HBufC8* textBuffer=HBufC8::NewLC(size);
+	TPtr8 bufPtr=textBuffer->Des();
+	dummy.ReadL(bufPtr,size);
+	iAttachmentFile.WriteFile(bufPtr);
+	iAttachmentFile.CloseFile();
+	delete iVcardStore;
+	iVcardStore=NULL;
+	CleanupStack::PopAndDestroy(2); // dummy, textBuffer
+	iMsvEntry->SetEntryL(iVcardId);
+	TMsvEmailEntry entry = iMsvEntry->Entry();
+	entry.iSize = size;
+	entry.iDetails.Set(iFileName);
+	entry.SetVCard(ETrue);
+	iVCardAndHtmlSize+=entry.iSize;
+	delete iMsvOperation;
+	iMsvOperation=NULL;
+	iMsvOperation=iMsvEntry->ChangeL(entry, iStatus);
+	}
+void CImEmailOperation::CreateAttachmentEntryL()
+	{
+	if (iMultipartMixedFolderCreated)
+		iMsvEntry->SetEntryL(iMultipartMixedId);
+	else
+		iMsvEntry->SetEntryL(iNewMessageId);
+	// create the index entry
+	TMsvEntry entry;
+	entry.iMtm = iMsgType;
+	entry.iServiceId = ServiceId();
+	entry.iType = KUidMsvAttachmentEntry;
+	entry.iDate.UniversalTime();
+	entry.SetAttachment(ETrue);
+	if (iAttachmentInfoList.Count())
+		{
+		// set the size and attachment name of the entry
+		CMsvAttachment* attachment = iAttachmentInfoList[iAttachmentCount];
+		entry.iSize = iAttachmentInfoList[iAttachmentCount]->Size();
+		if(iAttachmentInfoList[iAttachmentCount]->AttachmentName().Length() == 0)
+			{
+			TParse parseFile;
+			parseFile.Set(iAttachmentInfoList[iAttachmentCount]->FilePath(),NULL,NULL);
+			entry.iDetails.Set(parseFile.NameAndExt());
+			}
+		else
+			{
+			entry.iDetails.Set(iAttachmentInfoList[iAttachmentCount]->AttachmentName());
+			}
+		}
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	iMsvOperation = iMsvEntry->CreateL(entry, iStatus);
+	}
+void CImEmailOperation::StoreAttachmentL()
+	{
+	RFile origAttachmentFile;
+	if (iAttachmentInfoList[iAttachmentCount]->Type() == CMsvAttachment::EMsvFile)
+		{
+		// Need to get a file handle for the original attachment.
+		TMsvId origAttachId = iAttachmentInfoList[iAttachmentCount]->Id();
+		iMsvEntry->SetEntryL(origAttachId);
+		CMsvStore* store = iMsvEntry->ReadStoreL();
+		CleanupStack::PushL(store);
+		MMsvAttachmentManager& origAttachmentMgr = store->AttachmentManagerL();
+		// This is an email attachment entry, so it only has one attachment per entry
+		origAttachmentFile = origAttachmentMgr.GetAttachmentFileL(0);
+		CleanupStack::PopAndDestroy(store);
+		CleanupClosePushL(origAttachmentFile);
+		}
+	TMsvId msvId = McliUtils::GetProgressIdL(*iMsvOperation);
+	iMsvEntry->SetEntryL(msvId);//pointing to the attachment
+	iStore = iMsvEntry->EditStoreL();
+	MMsvAttachmentManager& attachmentMgr = iStore->AttachmentManagerL();
+	// Reset the Id to 1, email attachments have one entry
+	iAttachmentInfoList[iAttachmentCount]->SetId(1);
+	CMsvAttachment* attachment = CMsvAttachment::NewL(*iAttachmentInfoList[iAttachmentCount]);
+	CleanupStack::PushL(attachment);
+	if(attachment->Type() == CMsvAttachment::EMsvFile)
+		{
+		attachmentMgr.AddAttachmentL(origAttachmentFile, attachment, iStatus);
+		CleanupStack::Pop(2, &origAttachmentFile);   // attachment, origAttachmentFile
+		}
+	else if(attachment->Type() == CMsvAttachment::EMsvLinkedFile)
+		{
+		attachmentMgr.AddLinkedAttachmentL(attachment->FilePath(), attachment, iStatus);
+		CleanupStack::Pop(attachment);
+		}
+	else if(attachment->Type() == CMsvAttachment::EMsvMessageEntry)
+		{
+		attachmentMgr.AddEntryAsAttachmentL(attachment->EntryAttachmentId(), attachment, iStatus);
+		CleanupStack::Pop(attachment);
+		}
+	else
+		{
+		// If we have hit this line then a new attachment type has been added
+		// so this function will need to be updated.
+		__ASSERT_DEBUG(0, gPanic(EImEmailOpUnknownAttachmentType));
+		}
+	}
+void CImEmailOperation::AddMessageAsAttachmentL()
+	{
+	TMsvId serviceId;
+	TMsvEmailEntry entry;
+	iMsvEntry->Session().GetEntry(iEmailMessage->Selection()[--iEmbeddedMessagesToProcess], serviceId, entry);
+	iMsvEntry->SetEntryL(entry.Parent());
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	if (iMultipartMixedFolderCreated)
+		iMsvOperation = iMsvEntry->CopyL(iEmailMessage->Selection()[iEmbeddedMessagesToProcess], iMultipartMixedId, iStatus);
+	else
+		iMsvOperation = iMsvEntry->CopyL(iEmailMessage->Selection()[iEmbeddedMessagesToProcess], iNewMessageId, iStatus);
+	}
+void CImEmailOperation::CreateMultipartAlternativeFolderEntryL()
+	{
+	if (iMultipartMixedFolderCreated)
+		iMsvEntry->SetEntryL(iMultipartMixedId);
+	else
+		iMsvEntry->SetEntryL(iNewMessageId);
+	TMsvEmailEntry entry;
+	entry.iType = KUidMsvFolderEntry;
+	entry.iMtm = iMsvEntry->Entry().iMtm;
+	entry.iServiceId = iMsvEntry->Entry().iServiceId;
+	entry.SetMessageFolderType(EFolderTypeAlternative);
+	entry.iSize = 0;
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	iMsvOperation = iMsvEntry->CreateL(entry, iStatus);
+	}
+void CImEmailOperation::AppendHtmlAttachmentL()
+	{
+	TBool copyHtml = EFalse;
+	HBufC* temp = NULL;
+	temp = iEmailMessage->GetUniversalResourceIdentifierL(iHtmlId, copyHtml);
+	delete temp;
+	temp = NULL;
+	if (copyHtml)
+		{
+		iMsvEntry->SetEntryL(iHtmlId);
+		TMsvEmailEntry entry(iMsvEntry->Entry());
+			CMsvStore* store = iMsvEntry->ReadStoreL();
+			CleanupStack::PushL(store);
+			MMsvAttachmentManager& attachmentMgr = store->AttachmentManagerL();
+			if(attachmentMgr.AttachmentCount())
+				{
+				// as this is email attachment entry , it has one attachment per entry
+				CMsvAttachment* attachment = attachmentMgr.GetAttachmentInfoL(0);
+				CleanupStack::PushL(attachment);
+				attachment->SetSize(entry.iSize);
+				attachment->SetComplete(entry.Complete());
+				// def070915 - propagated fix
+				attachment->SetId(iHtmlId);
+				CleanupStack::Pop(attachment);
+				iAttachmentInfoList.Append(attachment);
+				++iTotalAttachments;
+				iPartList=iPartList|KMsvMessagePartAttachments;
+				}
+			CleanupStack::PopAndDestroy(store);
+		}
+	RequestComplete(KErrNone);
+	}
+/**
+Creates another CImEmailOperation object that creates a copy of the original
+message as an attachment to this message.
+The partlist supplied to the current CImEmailOperation is passed to the new one
+but ensuring that the orginator and recipient lists are included in the copy.
+The copied message is attached as a child of the Multipart Mixed folder entry if
+it exists or as a child of this message's message entry.
+*/
+void CImEmailOperation::AttachOriginalMessageToNewMessageL()
+	{
+	TMsvPartList partList = iPartList | KMsvMessagePartRecipient | KMsvMessagePartOriginator;
+	TInt typeList = 0;
+	if( iOrigMessageHtml )
+		typeList |= KMsvEmailTypeListMHTMLMessage;
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	if( iMultipartMixedFolderCreated )
+		iMsvOperation = CImEmailOperation::CreateCopyL(iStatus, iMsvSession, iOrigMessageId, iMultipartMixedId, partList, typeList, iMsgType);
+	else
+		iMsvOperation = CImEmailOperation::CreateCopyL(iStatus, iMsvSession, iOrigMessageId, iNewMessageId, partList, typeList, iMsgType);
+	}
+void CImEmailOperation::CompleteEmailOperationL()
+	{
+	//	1.	Set the Details (and Description if applicable)
+	//	2.	Set the Size = Size of Header + Size of Body + Size of Attachments
+	iMsvEntry->SetEntryL(iNewMessageId);	//pointing to the message
+	TMsvEmailEntry entry(iMsvEntry->Entry());
+	// Set the service id and the related id if the message we have created is a PCMail
+	// Note that this only needs to be done for Reply as otherwise we don't know the service.
+	// The service id will already be set for New and Forward PCMails if the service id was passed
+	// into the Constructor.
+	if( iMsgType == KUidMsgTypePCMail )
+		entry.iServiceId = entry.iRelatedId = ServiceId();
+	// if there are multiple recipients then set the flag
+	if( (iNewHeader->ToRecipients().Count() + iNewHeader->CcRecipients().Count() + iNewHeader->BccRecipients().Count()) > 1 )
+		entry.SetMultipleRecipients(ETrue);
+	if( iNewHeader->ToRecipients().Count() )
+		entry.iDetails.Set(iNewHeader->ToRecipients()[0]);
+	else if( iNewHeader->CcRecipients().Count() )
+		entry.iDetails.Set(iNewHeader->CcRecipients()[0]);
+	else if( iNewHeader->BccRecipients().Count() )
+		entry.iDetails.Set(iNewHeader->BccRecipients()[0]);
+	//else do nothing as there are no recipients yet!
+	entry.iDescription.Set(iNewHeader->Subject());
+	entry.iDate.UniversalTime();
+	TInt sizeOfHeader = iNewHeader->DataSize();
+	// only add the size of the rich text if the body is required or a signature has been added
+	// as otherwise it is not added
+	TInt sizeOfBody = 0;
+	if( iSignatureText || (iPartList & KMsvMessagePartBody) )
+		{
+		if(iUsePlainTextStorage)
+			{
+			iEmailMessage->GetBodyTextEntryIdL(iNewMessageId,CImEmailMessage::EThisMessageOnly);
+			sizeOfBody = GetPlainBodyTextSizeL();
+			iMsvEntry->SetEntryL(iNewMessageId);
+			}
+		else
+			{
+			// DocumentLength() gives no. of chars and since unicode we multiply by 2
+			sizeOfBody = (iRichText->DocumentLength() * 2);
+			}
+		}
+	TInt sizeOfAttachments = 0;
+	if( (iOperation != ENew) && (iPartList & KMsvMessagePartAttachments) )
+		{
+		for( TInt i=0; i<iTotalAttachments; ++i )
+			{
+			sizeOfAttachments += iAttachmentInfoList[i]->Size();
+			}
+		}
+	TInt sizeOfAttachedMessage = 0;
+	if( iOperation & EAttachOriginal )
+		{
+		TMsvId serviceId;
+		TMsvEmailEntry attachedMessageEntry;
+		iMsvEntry->Session().GetEntry(iAttachedMessageId, serviceId, attachedMessageEntry);
+		sizeOfAttachedMessage = attachedMessageEntry.iSize;
+		}
+	entry.iSize = sizeOfHeader + sizeOfBody + sizeOfAttachments + sizeOfAttachedMessage + iVCardAndHtmlSize;
+	// For receipt messages set the sending state to KMsvSendStateWaiting as receipts can be sent
+	// immediately
+	// For all others messages, use the setting in the SMTP settings
+	if( iOperation == EReceipt )
+		entry.SetSendingState(KMsvSendStateWaiting);
+	else if( iMsgType == KUidMsgTypeSMTP && iOperation != ECopy )
+		{
+		TUint sendState = 0;
+		switch( iSmtpSettings->SendMessageOption() )
+			{
+		case ESendMessageImmediately: // No send state for this !!
+		case ESendMessageOnNextConnection:
+			sendState = KMsvSendStateWaiting;
+			break;
+		case ESendMessageOnRequest:
+		default:
+			sendState = KMsvSendStateUponRequest;
+			break;
+			}
+		entry.SetSendingState(sendState);
+		}
+	// If a VCard has been added then the attachment flag needs to be set
+	if( iVcardId || (iTotalAttachments > 0) )
+		{
+		entry.SetAttachment(ETrue);
+		}
+	if(iVcardId)
+		{
+		// The vcard is set on the actual email entry.
+		entry.SetVCard(ETrue);
+		}
+	if( iOperation != ECopy )
+		{
+		// Adding a receipt flag or adding body encoding to the header does not
+		// apply to ECopy operations.
+		// Add receipt flag if required (check SMTP settings)
+		if( (iMsgType == KUidMsgTypeSMTP) && (iOperation != EReceipt) && (iSmtpServiceId != KMsvUnknownServiceIndexEntryId) )
+			{
+			if( iSmtpSettings->RequestReceipts() )
+				{
+				if( iSmtpSettings->ReceiptAddress().Length() )
+					iNewHeader->SetReceiptAddressL(iSmtpSettings->ReceiptAddress());
+				else if( iSmtpSettings->ReplyToAddress().Length() )
+					iNewHeader->SetReceiptAddressL(iSmtpSettings->ReplyToAddress());
+				// else don't know who to send a receipt to - receipt will not be sent.
+				if( iNewHeader->ReceiptAddress().Length() )
+					entry.SetReceipt(ETrue);
+				}
+			}
+		// Store the body encoding in the header from the SMTP account settings
+		// if the user is creating a plaintext message even though the settings
+		// specify HTML message, the body encoding is set to EMsgOutboxMIME
+		if( iCreateHtmlMessage )
+			iNewHeader->SetBodyEncoding(EMsgOutboxMHTMLAlternativeAsMIME);
+		else if( (iMsgType == KUidMsgTypeSMTP) || (iSmtpSettings->BodyEncoding() != EMsgOutboxMHTMLAlternativeAsMIME) )
+			iNewHeader->SetBodyEncoding(iSmtpSettings->BodyEncoding());
+		else
+			iNewHeader->SetBodyEncoding(EMsgOutboxMIME);
+		}
+	CMsvStore* store = iMsvEntry->EditStoreL();
+	CleanupStack::PushL(store);
+	// store the header - this has not been done previously
+	iNewHeader->StoreL(*store);
+	if( iMultipartMixedFolderCreated || iMultipartAlternativeFolderCreated )
+		{
+		CImMimeHeader* mimeHeader = CImMimeHeader::NewLC();
+		mimeHeader->SetContentTypeL(KMimeMultipart);
+		if( iMultipartMixedFolderCreated )
+			mimeHeader->SetContentSubTypeL(KMimeMixed);
+		else
+			mimeHeader->SetContentSubTypeL(KMimeAlternative);
+		mimeHeader->SetContentTransferEncodingL(KMimeQuotedPrintable);
+		mimeHeader->StoreL(*store);
+		entry.iSize += mimeHeader->Size();
+		CleanupStack::PopAndDestroy(mimeHeader);
+		}
+	store->CommitL();
+	CleanupStack::PopAndDestroy(store);
+	delete iMsvOperation;
+	iMsvOperation=NULL;
+	iMsvOperation=iMsvEntry->ChangeL(entry, iStatus);
+	}
+void CImEmailOperation::CreateHTMLEntryL()
+	{
+	iMsvEntry->SetEntryL(iMultipartAlternativeId);
+	TMsvEntry entry;
+	entry.iServiceId = ServiceId();
+	entry.iType = KUidMsvEmailHtmlEntry;
+	entry.iMtm = iMsvEntry->Entry().iMtm;
+	entry.iDate.UniversalTime();
+	entry.iSize = 0;
+	delete iMsvOperation;
+	iMsvOperation = NULL;
+	iMsvOperation = iMsvEntry->CreateL(entry, iStatus);
+	iHtmlId = iMsvEntry->Entry().Id();
+	}
+void CImEmailOperation::AddMessageAttachmentInfoL(TMsvId aAttachmentMessageId)
+	{
+	iMsvEntry->SetEntryL(aAttachmentMessageId);
+	iStore = iMsvEntry->EditStoreL();
+	MMsvAttachmentManager& attachmentMgr = iStore->AttachmentManagerL();
+	CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvMessageEntry);
+	CleanupStack::PushL(attachment);
+	attachmentMgr.AddEntryAsAttachmentL(aAttachmentMessageId,attachment,iStatus);
+	CleanupStack::Pop(attachment);
+	}
+void CImEmailOperation::CreateDefaultAttachmentL()
+	{
+	MMsvAttachmentManager& attachmentMgr = iStore->AttachmentManagerL();
+	CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
+	TFileName fileName;
+	ReadDefaultHtmlAttachmentNameL(fileName);
+	attachmentMgr.CreateAttachmentL(fileName,iFile,attachment,iStatus);
+	}
+void CImEmailOperation::ReadDefaultHtmlAttachmentNameL(TDes& aFileName)
+	{
+	RResourceFile resourceFile;
+	OpenResourceFileL(resourceFile, iMsvSession.FileSession());
+	CleanupClosePushL(resourceFile);
+	TResourceReader reader;
+	HBufC8* buf = resourceFile.AllocReadLC( DEFAULT_ATTACHMENT_NAME );
+	reader.SetBuffer(buf);
+	TPtrC attachmentName = reader.ReadTPtrC();
+	const TDesC& ext = KMimeHtmlExtension;
+	HBufC* defaultAttachmentName = HBufC::NewL(attachmentName.Length() + ext.Length());
+	CleanupStack::PushL(defaultAttachmentName);
+	defaultAttachmentName->Des().Copy(attachmentName);
+	defaultAttachmentName->Des().Append(ext);
+	aFileName.Append(*defaultAttachmentName);
+	CleanupStack::PopAndDestroy(3,&resourceFile ); //buf, defaultAttachmentName,resourceFile (Close resourceFile)
+	}
+void CImEmailOperation::ResetStoreL()
+	{
+	iStore->CommitL();
+	delete iStore;
+	iStore = NULL;
+	}
+/**
+Method that will be called when object in RPointerArray<CMsvPlainBodyText> is deleted.
+@param aPtr		Pointer to the RPointerArray.
+@return void.
+*/
+void CImEmailOperation::ClosePlainBodyTextArray( TAny* aPtr )
+	{
+	RPointerArray<CMsvPlainBodyText>* plainBodyTextArray = reinterpret_cast<RPointerArray<CMsvPlainBodyText>*> (aPtr);
+	plainBodyTextArray->ResetAndDestroy();
+	}
+/**
+Return the size of the body text for a email message.
+*/
+TInt CImEmailOperation::GetPlainBodyTextSizeL()
+	{
+	TInt count = iEmailMessage->Selection().Count();
+	TInt sizeOfBody = 0;
+	for(TInt i=0; i< count ;++i)
+		{
+		iMsvEntry->SetEntryL(iEmailMessage->Selection().At(i));	//pointing to the text entry
+		CMsvStore* bodyTextStore = iMsvEntry->ReadStoreL();
+		CleanupStack::PushL(bodyTextStore);
+		CMsvPlainBodyText* plainBodyText = bodyTextStore->InitialisePlainBodyTextForReadL(KMaxChunkLength);
+		sizeOfBody += plainBodyText->Size();
+		delete plainBodyText;
+		plainBodyText = NULL;
+		CleanupStack::PopAndDestroy(bodyTextStore);
+		bodyTextStore = NULL;
+		}
+	return 	sizeOfBody;
+	}
+void CImHtmlConverter::ResetStoreL()
+	{
+	if(iStore != NULL )
+		{
+		iStore->CommitL();
+		delete iStore;
+		iStore = NULL;
+		}
+	}
+void CImHtmlConverter::ResetStoreWithoutCommit()
+	{
+	if (this != NULL)
+	 	{
+	 	if(iStore != NULL )
+	 		{
+	 		delete iStore;
+	 		iStore = NULL;
+	 		}
+	 	}
+	}
+//-----------------------------------------------------------------
+//-----------------------------------------------------------------
+CImHtmlConverter* CImHtmlConverter::NewL(CMsvEntry& aMsvEntry,
+								   CParaFormatLayer& aParaLayer, CCharFormatLayer& aCharLayer)
+	{
+	CImHtmlConverter* self = new (ELeave) CImHtmlConverter(aMsvEntry, aParaLayer, aCharLayer);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop();
+	return self;
+	}
+CImHtmlConverter::CImHtmlConverter(CMsvEntry& aMsvEntry, CParaFormatLayer& aParaLayer, CCharFormatLayer& aCharLayer)
+:iMsvEntry(aMsvEntry), iParaLayer(aParaLayer), iCharLayer(aCharLayer)
+{
+}
+void CImHtmlConverter::ConstructL()
+	{
+	_LIT8(KHtmlInMimeType, "epoc32/crichtext");
+	_LIT8(KHtmlOutMimeType, "text/html");
+	TDataType inMimeType(KHtmlInMimeType);
+	TDataType outMimeType(KHtmlOutMimeType);
+	iConverterList = CCnaConverterList::NewL();
+	iConverterList->UpdateL();
+	TUid uid = iConverterList->ConverterL(inMimeType, outMimeType);
+	iToHTMLConverter = iConverterList->NewConverterL(uid);
+	User::LeaveIfNull(iToHTMLConverter);
+	User::LeaveIfError(iToHTMLConverter->Capabilities() & CConverterBase::EConvertsFiles);
+	}
+void CImHtmlConverter::PrepareToStoreHTMLEntryTextL (TMsvId& aHtmlId, const TMsvId aTextId)
+	{
+	// 0. Check html entry exists.
+	if (!aHtmlId)
+		{
+		iMsvEntry.SetEntryL(iMsvEntry.Entry().Parent());	//pointing to the text entry
+		if ( ((TMsvEmailEntry)iMsvEntry.Entry()).MessageFolderType() != EFolderTypeAlternative)
+			return;
+		TInt i = iMsvEntry.Count();
+		while (i--)
+			{
+			if (aTextId!=iMsvEntry[i].Id())
+				{
+				aHtmlId=iMsvEntry[i].Id();
+				break;
+				}
+			}
+		}
+	if (aHtmlId <=0)
+		return;
+	// 1. Create file containing Rich text.
+	iMsvEntry.SetEntryL(aTextId);	//pointing to the text entry
+	TFileName filepath;
+// Create the file with Rich text in non secure version
+	CMsvStore* store=NULL;
+TRAPD(err,store=iMsvEntry.ReadStoreL());
+	if (err)
+		{
+		aHtmlId=0;
+	    User::Leave(err);
+		}
+	CleanupStack::PushL(store);
+	if ( !store->IsPresentL(KMsvEntryRichTextBody) && !store->IsPresentL(KMsvPlainBodyText16) && !store->IsPresentL(KMsvPlainBodyText8))
+		{
+		aHtmlId=0;
+		User::Leave(KErrNotFound); // Rich text not found
+		}
+	CRichText* bodyText=CRichText::NewL(&iParaLayer,&iCharLayer);
+	CleanupStack::PushL(bodyText);
+	store->RestoreBodyTextL(*bodyText);
+	if (bodyText->PictureCount())
+		{
+		RMsvReadStream in;
+		in.OpenL(*store, KMsvEntryRichTextBody);
+		CEmbeddedStore* embeddedStore = CEmbeddedStore::FromL(in);
+		// Create store resolver
+		CImStoreResolver* storeResolver = new(ELeave)CImStoreResolver(embeddedStore); // Takes ownership
+		CleanupStack::PushL(storeResolver);
+		// Set the picture factory
+		__ASSERT_ALWAYS(CEikonEnv::Static(), gPanic(EImcmNoEikonEnvironment));
+		MPictureFactory* factory = CEikonEnv::Static()->PictureFactory();
+		bodyText->SetPictureFactory(factory, storeResolver);
+		bodyText->DetachFromStoreL(CPicture::EDetachFull);
+		CleanupStack::PopAndDestroy(storeResolver);
+		}
+	CleanupStack::Pop(bodyText);
+	delete iRichText;
+	iRichText = NULL;
+	iRichText = bodyText;
+	TPckgBuf<CRichText*> bufferRichText(iRichText); //text to be converted
+	iSourceStream.Open(bufferRichText);
+	CleanupStack::PopAndDestroy(store);
+	// 2. Convert to HTML file
+	iMsvEntry.SetEntryL(aHtmlId);
+	iStore = iMsvEntry.EditStoreL();
+	MMsvAttachmentManager& attachmentMgr = iStore->AttachmentManagerL();
+	iFile = attachmentMgr.GetAttachmentFileForWriteL(0);
+	// open the write stream setting with file handle
+	iTargetStream.Attach(iFile);
+	// Prepares for asyn conversion.
+	iHtmlId=aHtmlId;
+	iTextId=aTextId;
+	iToHTMLConverter->ConvertObjectAL(iSourceStream,iTargetStream);
+	}
+TBool CImHtmlConverter::StoreHTMLEntryTextAL(TRequestStatus& aStatus)
+	{
+	TBool finishedConvertingHTML = (!iToHTMLConverter->DoConvertL());
+	if (finishedConvertingHTML)
+		{
+		TFileName filepath;
+		RDir dir;
+		TEntry entry;
+		TParse dirPath;
+		iToHTMLConverter->CancelConvert();
+		iSourceStream.Close();
+		iTargetStream.CommitL();
+		iTargetStream.Close();
+		iFile.Close();
+		ResetStoreL();
+		// Set to html attachment entry
+		iMsvEntry.SetEntryL(iHtmlId);
+		iStore = iMsvEntry.EditStoreL();
+		MMsvAttachmentManager& attachmentMgr = iStore->AttachmentManagerL();
+		// Email Mtm will have one attachment per attachment entry , ehnce index 0
+		CMsvAttachment* attachment = attachmentMgr.GetAttachmentInfoL(0);
+		RFile file = attachmentMgr.GetAttachmentFileL(0);
+		CleanupStack::PushL(attachment);
+		TInt error = file.Size(iSize);
+		if(error == KErrNone)
+			attachment->SetSize(iSize);
+		file.Close();
+		TFileName filename = HtmlFilename(iMsvEntry, GetDefaultAttachmentName());
+		attachment->SetAttachmentNameL(filename);
+		CleanupStack::Pop(attachment); // ownership passed to attachment manager
+		attachmentMgr.ModifyAttachmentInfoL(attachment,aStatus);
+		return 	finishedConvertingHTML; // true
+		}
+	return finishedConvertingHTML; // false
+	}
+CMsvOperation*CImHtmlConverter::ChangeHTMLTextInEnrtyL(TRequestStatus& aStatus)
+	{
+	TMsvEmailEntry emailEntry = iMsvEntry.Entry();
+	TFileName filename = HtmlFilename(iMsvEntry, GetDefaultAttachmentName());
+	emailEntry.iDetails.Set(filename);
+	emailEntry.iSize = iSize;
+	return iMsvEntry.ChangeL(emailEntry, aStatus);
+	}
+TFileName CImHtmlConverter::HtmlFilename(CMsvEntry& aEntry, TPtrC aFileName)
+	{
+	TFileName path;
+	TFileName name;
+	TMsvEntry entry = aEntry.Entry();
+// this is not used at all , need to get rid of this
+	if (entry.iDetails.Length())
+		name=entry.iDetails;
+	else if (aFileName.Length())
+		name.Copy(aFileName);
+	return name;
+	}
+void CImHtmlConverter::ReadDefaultAttachmentNameL(RResourceFile& resourceFile)
+	{
+	TResourceReader reader;
+	HBufC8* buf;
+	buf = resourceFile.AllocReadLC( DEFAULT_ATTACHMENT_NAME );
+	reader.SetBuffer(buf);
+	TPtrC attachmentName = reader.ReadTPtrC();
+	const TDesC& ext = KMimeHtmlExtension;
+	iDefaultAttachmentName = HBufC::NewL(attachmentName.Length() + ext.Length());
+	iDefaultAttachmentName->Des().Copy(attachmentName);
+	iDefaultAttachmentName->Des().Append(ext);
+	CleanupStack::PopAndDestroy(); // buf
+	}
+TPtrC CImHtmlConverter::GetDefaultAttachmentName()
+	{
+	return (iDefaultAttachmentName) ? iDefaultAttachmentName->Des() : TPtrC();
+	}
+CImHtmlConverter::~CImHtmlConverter()
+	{
+	delete iToHTMLConverter;
+	delete iDefaultAttachmentName;
+	delete iConverterList;
+	delete iRichText;
+	iSourceStream.Close();
+	iTargetStream.Close();
+	iFile.Close();
+	delete iStore;
+	}
+TInt CImHtmlConverter::Size() const
+	{
+	return iSize;
+	}
+//**********************************
+// CImStoreResolver
+//**********************************
+CImStoreResolver::CImStoreResolver(CStreamStore* aStore)
+: iStore(aStore)
+	{
+	}
+CImStoreResolver::~CImStoreResolver()
+	{
+	delete iStore;
+	}
+const CStreamStore& CImStoreResolver::StreamStoreL(TInt) const
+	{
+	return *iStore;
+	}

changeset 0	72b543305e3a
child 9	1d7827e39b52