/*
* Copyright (c) 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: This file implements class CEmailMessage.
*
*/
#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <viewclipartner.h>
#include <vwsdefpartner.h>
#else
#include <viewcli.h>
#include <vwsdef.h>
#endif // SYMBIAN_ENABLE_SPLIT_HEADERS
#include "emailmessage.h"
#include "emailaddress.h"
#include "emailapiutils.h"
#include "emailclientapi.hrh"
#include "emailapiutils.h"
#include "emailinterfacefactoryimpl.h"
#include "emailcontent.h"
#include "emailtextcontent.h"
#include "emailmultipart.h"
#include "emailattachment.h"
#include "cfsmailplugin.h"
#include "FreestyleEmailUiConstants.h"
#include "cfsmailclient.h"
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
CEmailMessage* CEmailMessage::NewL( CPluginData& aPluginData,
CFSMailMessage* aFsMessage,
const TDataOwner aOwner )
{
CEmailMessage* message = new ( ELeave ) CEmailMessage( aPluginData, aFsMessage, aOwner );
CleanupStack::PushL( message );
message->ConstructL();
CleanupStack::Pop();
return message;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
CEmailMessage::CEmailMessage(
CPluginData& aPluginData,
CFSMailMessage *aFsMessage,
const TDataOwner aOwner)
: iPluginData( aPluginData ), iPluginMessage( aFsMessage ), iOwner( aOwner )
{
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CEmailMessage::ConstructL()
{
iPlugin = iPluginData.ClaimInstanceL();
if ( iPluginMessage )
{
iMessageId = TMessageId(
iPluginMessage->GetMessageId().Id(),
iPluginMessage->GetFolderId().Id(),
iPluginMessage->GetMailBoxId().Id() );
// Copy the message flags
InitializeFlagValues();
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
CEmailMessage::~CEmailMessage()
{
delete iPluginMessage;
delete iSender;
delete iReplyTo;
delete iTextContent;
delete iContent;
iPluginData.ReleaseInstance();
iAttachments.ResetAndDestroy();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
TEmailTypeId CEmailMessage::InterfaceId() const
{
return KEmailIFUidMessage;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CEmailMessage::Release()
{
if ( iOwner == EClientOwns )
{
delete this;
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
const TMessageId& CEmailMessage::MessageId() const
{
return iMessageId;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
MEmailAddress* CEmailMessage::SenderAddressL() const
{
CFSMailAddress* fsAddress = iPluginMessage->GetSender();
if (fsAddress)
{
if (!iSender)
{
iSender = CEmailAddress::NewL( MEmailAddress::ESender, EAPIOwns );
}
iSender->SetAddressL(fsAddress->GetEmailAddress());
iSender->SetDisplayNameL(fsAddress->GetDisplayName());
}
else
{
// Sender address not defined. Delete client object as well
delete iSender;
iSender = NULL;
}
return iSender;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
MEmailAddress* CEmailMessage::ReplyToAddressL() const
{
const CFSMailAddress& fsAddress = iPluginMessage->GetReplyToAddress();
if ( &fsAddress )
{
if (!iReplyTo)
{
iReplyTo = CEmailAddress::NewL( MEmailAddress::EReplyTo, EAPIOwns );
}
iReplyTo->SetAddressL( fsAddress.GetEmailAddress() );
iReplyTo->SetDisplayNameL( fsAddress.GetDisplayName() );
}
else
{
delete iReplyTo;
iReplyTo = NULL;
}
return iReplyTo;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CEmailMessage::SetReplyToAddressL( const MEmailAddress& aSender )
{
CFSMailAddress *fsAddress = CFSMailAddress::NewLC();
if (!iReplyTo)
{
iReplyTo = CEmailAddress::NewL( MEmailAddress::EReplyTo, EAPIOwns);
}
fsAddress->SetDisplayName( aSender.DisplayName() );
fsAddress->SetEmailAddress( aSender.Address() );
iPluginMessage->SetReplyToAddress( fsAddress );
iReplyTo->SetAddressL( fsAddress->GetEmailAddress() );
iReplyTo->SetDisplayNameL( fsAddress->GetDisplayName() );
CleanupStack::Pop();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
TInt CEmailMessage::GetRecipientsL( const MEmailAddress::TRole aRole,
REmailAddressArray& aRecipients ) const
{
if( aRole == MEmailAddress::EReplyTo ||
aRole == MEmailAddress::ESender )
{
User::Leave( KErrArgument );
}
else
{
if( aRole == MEmailAddress::ETo ||
aRole == MEmailAddress::EUndefined )
{
RPointerArray<CFSMailAddress>& toRecipients =
iPluginMessage->GetToRecipients();
ConvertAddressArrayL(
MEmailAddress::ETo,
toRecipients, aRecipients );
}
if( aRole == MEmailAddress::ECc ||
aRole == MEmailAddress::EUndefined )
{
RPointerArray<CFSMailAddress>& ccRecipients =
iPluginMessage->GetCCRecipients();
ConvertAddressArrayL(
MEmailAddress::ECc,
ccRecipients, aRecipients );
}
if( aRole == MEmailAddress::EBcc ||
aRole == MEmailAddress::EUndefined )
{
RPointerArray<CFSMailAddress>& bccRecipients =
iPluginMessage->GetBCCRecipients();
ConvertAddressArrayL(
MEmailAddress::EBcc,
bccRecipients, aRecipients );
}
}
return aRecipients.Count();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CEmailMessage::SetRecipientsL( const MEmailAddress::TRole aRole,
REmailAddressArray& aRecipients )
{
TInt count( aRecipients.Count() );
for( TInt i=0;i<count;i++ )
{
const MEmailAddress* address = aRecipients[i];
CFSMailAddress* fsAddress = CFSMailAddress::NewLC();
fsAddress->SetEmailAddress( address->Address() );
fsAddress->SetDisplayName( address->DisplayName() );
if( aRole == MEmailAddress::ETo )
{
iPluginMessage->AppendToRecipient( fsAddress );
}
else if( aRole == MEmailAddress::ECc )
{
iPluginMessage->AppendCCRecipient( fsAddress );
}
else if( aRole == MEmailAddress::EBcc )
{
iPluginMessage->AppendBCCRecipient( fsAddress );
}
else
{
User::Leave( KErrArgument );
}
CleanupStack::Pop( fsAddress );
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CEmailMessage::RemoveRecipientL( const MEmailAddress& aRecipient )
{
TInt err( KErrNotFound );
RPointerArray<CFSMailAddress>* recipients = NULL;
switch (aRecipient.Role())
{
case MEmailAddress::ETo:
recipients = &iPluginMessage->GetToRecipients();
break;
case MEmailAddress::ECc:
recipients = &iPluginMessage->GetCCRecipients();
break;
case MEmailAddress::EBcc:
recipients = &iPluginMessage->GetBCCRecipients();
break;
default:
User::Leave( KErrArgument );
break;
}
for( TInt i = 0; i < recipients->Count(); i++ )
{
if ( !aRecipient.Address().Compare( (*recipients)[i]->GetEmailAddress() ) )
{
recipients->Remove(i);
err = KErrNone;
// We could break now. But let's loop if there are several entries
}
}
User::LeaveIfError( err );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
TPtrC CEmailMessage::Subject() const
{
return iPluginMessage->GetSubject();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CEmailMessage::SetSubjectL( const TPtrC& aSubject)
{
iPluginMessage->SetSubject( aSubject );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
TTime CEmailMessage::Date() const
{
return iPluginMessage->GetDate();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
TInt CEmailMessage::Flags() const
{
return iFlags;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CEmailMessage::SetFlag( const TUint aFlag )
{
iFlags |= aFlag;
TUint flag = MapFlags( aFlag );
iPluginMessage->SetFlag( flag );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CEmailMessage::ResetFlag( const TUint aFlag )
{
iFlags &= ~aFlag;
TUint flag = MapFlags( aFlag );
iPluginMessage->ResetFlag( flag );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CEmailMessage::InitializeFlagValues()
{
// 1st reset member value, then start copying different flags
iFlags = 0;
// EFlag_Read
if ( iPluginMessage->IsFlagSet( EFSMsgFlag_Read ) )
{
iFlags |= EFlag_Read;
}
else
{
iFlags &= ~EFlag_Read;
}
// EFlag_Read_Locally
if ( iPluginMessage->IsFlagSet( EFSMsgFlag_Read_Locally ) )
{
iFlags |= EFlag_Read_Locally;
}
else
{
iFlags &= ~EFlag_Read_Locally;
}
// EFlag_Low
if ( iPluginMessage->IsFlagSet( EFSMsgFlag_Low ) )
{
iFlags |= EFlag_Low;
}
else
{
iFlags &= ~EFlag_Low;
}
// EFlag_Important
if ( iPluginMessage->IsFlagSet( EFSMsgFlag_Important ) )
{
iFlags |= EFlag_Important;
}
else
{
iFlags &= ~EFlag_Important;
}
// EFlag_FollowUpComplete
if ( iPluginMessage->IsFlagSet( EFSMsgFlag_FollowUpComplete ) )
{
iFlags |= EFlag_FollowUpComplete;
}
else
{
iFlags &= ~EFlag_FollowUpComplete;
}
// EFlag_FollowUp
if ( iPluginMessage->IsFlagSet( EFSMsgFlag_FollowUp ) )
{
iFlags |= EFlag_FollowUp;
}
else
{
iFlags &= ~EFlag_FollowUp;
}
// EFlag_Attachments
if ( iPluginMessage->IsFlagSet( EFSMsgFlag_Attachments ) )
{
iFlags |= EFlag_Attachments;
}
else
{
iFlags &= ~EFlag_Attachments;
}
// EFlag_Multiple
if ( iPluginMessage->IsFlagSet( EFSMsgFlag_Multiple ) )
{
iFlags |= EFlag_Multiple;
}
else
{
iFlags &= ~EFlag_Multiple;
}
// EFlag_CalendarMsg
if ( iPluginMessage->IsFlagSet( EFSMsgFlag_CalendarMsg ) )
{
iFlags |= EFlag_CalendarMsg;
}
else
{
iFlags &= ~EFlag_CalendarMsg;
}
// EFlag_Answered
if ( iPluginMessage->IsFlagSet( EFSMsgFlag_Answered ) )
{
iFlags |= EFlag_Answered;
}
else
{
iFlags &= ~EFlag_Answered;
}
// EFlag_Forwarded
if ( iPluginMessage->IsFlagSet( EFSMsgFlag_Forwarded ) )
{
iFlags |= EFlag_Forwarded;
}
else
{
iFlags &= ~EFlag_Forwarded;
}
// EFlag_OnlyToMe
if ( iPluginMessage->IsFlagSet( EFSMsgFlag_OnlyToMe ) )
{
iFlags |= EFlag_OnlyToMe;
}
else
{
iFlags &= ~EFlag_OnlyToMe;
}
// EFlag_RemoteDeleted
if ( iPluginMessage->IsFlagSet( EFSMsgFlag_RemoteDeleted ) )
{
iFlags |= EFlag_RemoteDeleted;
}
else
{
iFlags &= ~EFlag_RemoteDeleted;
}
// EFlag_HasMsgSender
if ( iPluginMessage->IsFlagSet( EFSMsgFlag_HasMsgSender ) )
{
iFlags |= EFlag_HasMsgSender;
}
else
{
iFlags &= ~EFlag_HasMsgSender;
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
MEmailMessageContent* CEmailMessage::ContentL() const
{
if (iTextContent)
{
return iTextContent;
}
if (iContent)
{
return iContent;
}
RPointerArray<CFSMailMessagePart> parts;
CleanupResetAndDestroyPushL( parts );
iPluginMessage->ChildPartsL(parts);
TInt count( parts.Count() );
if( count == 0 )
{
/* No content, return NULL */
CleanupStack::Pop(); // parts
return NULL;
}
CFSMailMessagePart* part = parts[0];
TContentType contentType( part->GetContentType() );
TMessageContentId msgContentId = TMessageContentId(
part->GetPartId().Id(),
iMessageId.iId,
iMessageId.iFolderId.iId,
iMessageId.iFolderId.iMailboxId );
if ( contentType.Equals( KFSMailContentTypeTextPlain ) ||
contentType.Equals( KFSMailContentTypeTextHtml ) )
{
iTextContent = CEmailTextContent::NewL(iPluginData, msgContentId, part, EAPIOwns );
}
else if ( contentType.Equals( KFSMailContentTypeMultipartMixed ) ||
contentType.Equals( KFSMailContentTypeMultipartAlternative ) ||
contentType.Equals( KFSMailContentTypeMultipartDigest ) ||
contentType.Equals( KFSMailContentTypeMultipartRelated ) ||
contentType.Equals( KFSMailContentTypeMultipartParallel ) )
{
iContent = CEmailMultipart::NewL(iPluginData, msgContentId, part, EAPIOwns);
}
if ( count == 2 )
{
CFSMailMessagePart* part = parts[1];
const TDesC& contentType = part->GetContentType();
}
CleanupStack::Pop(); // parts
if (iTextContent)
{
return iTextContent;
}
return iContent;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CEmailMessage::SetContentL( const MEmailMessageContent* aContent )
{
MEmailTextContent* textContent = aContent->AsTextContentOrNull();
if (textContent)
{
if (iTextContent)
{
delete iTextContent; // Destroy old content
}
iTextContent = dynamic_cast<CEmailTextContent*>(textContent);
if ( iTextContent )
{
iTextContent->SetOwner( EAPIOwns );
}
return;
}
MEmailMultipart* mPart = aContent->AsMultipartOrNull();
if (mPart)
{
if (iContent)
{
delete iContent;
}
iContent = dynamic_cast<CEmailMultipart*>(mPart);
if ( iContent )
{
iContent->SetOwner( EAPIOwns );
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CEmailMessage::SetPlainTextBodyL( const TDesC& aPlainText )
{
if (iTextContent)
{
iTextContent->SetTextL( MEmailTextContent::EPlainText, aPlainText );
return;
}
CFSMailMessagePart* msgTextPart = iPluginMessage->PlainTextBodyPartL();
if( !msgTextPart )
{
msgTextPart = iPluginMessage->NewChildPartL( TFSMailMsgId(), KFSMailContentTypeTextPlain );
}
CleanupStack::PushL( msgTextPart );
TMessageContentId msgContentId = TMessageContentId(
msgTextPart->GetPartId().Id(),
iMessageId.iId,
iMessageId.iFolderId.iId,
iMessageId.iFolderId.iMailboxId );
msgTextPart->SetContentType( KFSMailContentTypeTextPlain );
iTextContent = CEmailTextContent::NewL( iPluginData, msgContentId, msgTextPart, EAPIOwns );
if (iTextContent)
{
iTextContent->SetTextL( MEmailTextContent::EPlainText, aPlainText );
}
CleanupStack::Pop(); // msgTextPart
return;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
MEmailAttachment* CEmailMessage::AddAttachmentL( const TDesC& aFullPath )
{
CFSMailMessagePart* part = iPluginMessage->AddNewAttachmentL(aFullPath, TFSMailMsgId());
CleanupStack::PushL( part );
CEmailAttachment* att = CEmailAttachment::NewLC(iPluginData, iMsgContentId, part, EAPIOwns);
iAttachments.AppendL( att );
CleanupStack::Pop(2); // part, att
return att;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
MEmailAttachment* CEmailMessage::AddAttachmentL( RFile& aFile )
{
TBufC8 <1> mime;
CFSMailMessagePart* part = iPluginMessage->AddNewAttachmentL(aFile, mime);
CleanupStack::PushL( part );
CEmailAttachment* att = CEmailAttachment::NewLC(iPluginData, iMsgContentId, part, EAPIOwns);
iAttachments.AppendL( att );
CleanupStack::Pop(); // part, att
return att;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
TInt CEmailMessage::GetAttachmentsL( REmailAttachmentArray& aAttachments )
{
RPointerArray<CFSMailMessagePart> attachments;
CleanupResetAndDestroyPushL( attachments );
iPluginMessage->AttachmentListL(attachments);
const TInt count( attachments.Count() );
for (TInt i = 0; i < count; i++)
{
TMessageContentId msgContentId = TMessageContentId(
attachments[i]->GetPartId().Id(),
iMessageId.iId,
iMessageId.iFolderId.iId,
iMessageId.iFolderId.iMailboxId );
CEmailAttachment* att = CEmailAttachment::NewL(iPluginData, msgContentId, attachments[i], EClientOwns);
aAttachments.AppendL(att);
}
CleanupStack::Pop(); // attachments
return count;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CEmailMessage::RemoveAttachmentL( const MEmailAttachment& aAttachment )
{
iPluginMessage->RemoveChildPartL(FsMsgId( iPluginData, aAttachment.Id()));
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
const TFolderId& CEmailMessage::ParentFolderId() const
{
return iMessageId.iFolderId;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CEmailMessage::SaveChangesL()
{
TFSMailMsgId mailboxId(
FsMsgId( iPluginData, iMessageId.iFolderId.iMailboxId ) );
iPlugin->StoreMessageL( mailboxId, *iPluginMessage );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CEmailMessage::SendL()
{
SaveChangesL();
iPlugin->SendMessageL( *iPluginMessage );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void CEmailMessage::ConvertAddressArrayL(
const MEmailAddress::TRole aRole,
RPointerArray<CFSMailAddress>& aSrc,
REmailAddressArray& aDst ) const
{
for ( TInt i=0; i<aSrc.Count(); i++ )
{
CEmailAddress* recipient = CreateAddressLC( aRole, *aSrc[i] );
aDst.AppendL( recipient );
CleanupStack::Pop( recipient );
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CEmailAddress* CEmailMessage::CreateAddressLC(
const MEmailAddress::TRole aRole,
CFSMailAddress& aFsAddress ) const
{
CEmailAddress* address = CEmailAddress::NewLC( aRole, EClientOwns );
TDesC& temp1 = aFsAddress.GetEmailAddress();
if ( &temp1 )
{
address->SetAddressL( temp1 );
}
TDesC& temp2 = aFsAddress.GetDisplayName();
if ( &temp2 )
{
address->SetDisplayNameL( temp2 );
}
return address;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TUint CEmailMessage::MapFlags( const TUint& aFlag )
{
TUint flag = 0;
switch( aFlag )
{
case EFlag_Read:
flag = EFSMsgFlag_Read;
break;
case EFlag_Read_Locally:
flag = EFSMsgFlag_Read_Locally;
break;
case EFlag_Low:
flag = EFSMsgFlag_Low;
break;
case EFlag_Important:
flag = EFSMsgFlag_Important;
break;
case EFlag_FollowUpComplete:
flag = EFSMsgFlag_FollowUpComplete;
break;
case EFlag_FollowUp:
flag = EFSMsgFlag_FollowUp;
break;
case EFlag_Attachments:
flag = EFSMsgFlag_Attachments;
break;
case EFlag_Multiple:
flag = EFSMsgFlag_Multiple;
break;
case EFlag_CalendarMsg:
flag = EFSMsgFlag_CalendarMsg;
break;
case EFlag_Answered:
flag = EFSMsgFlag_Answered;
break;
case EFlag_Forwarded:
flag = EFSMsgFlag_Forwarded;
break;
case EFlag_OnlyToMe:
flag = EFSMsgFlag_OnlyToMe;
break;
case EFlag_RemoteDeleted:
flag = EFSMsgFlag_RemoteDeleted;
break;
case EFlag_HasMsgSender:
flag = EFSMsgFlag_HasMsgSender;
break;
default:
break;
}
return flag;
}
void CEmailMessage::ShowMessageViewerL( )
{
THtmlViewerActivationData htmlData;
htmlData.iActivationDataType = THtmlViewerActivationData::EMailMessage;
htmlData.iMailBoxId = FsMsgId(iPluginData, iMessageId.iFolderId.iMailboxId);
htmlData.iFolderId = FsMsgId(iPluginData, iMessageId.iFolderId);
htmlData.iMessageId = FsMsgId(iPluginData, iMessageId);
TPckgBuf<THtmlViewerActivationData> pckgData( htmlData );
CVwsSessionWrapper* viewSrvSession = CVwsSessionWrapper::NewLC();
viewSrvSession->ActivateView(TVwsViewId(KFSEmailUiUid, HtmlViewerId), KHtmlViewerOpenNew, pckgData);
CleanupStack::PopAndDestroy();
}
/**
* Launches Email application and new reply message in editor.
* The method follows "fire and forget" pattern, returns immediately.
*/
void CEmailMessage::ReplyToMessageL( const TBool aReplyToAll )
{
TEditorLaunchParams editorLaunchData;
editorLaunchData.iExtra = NULL;
editorLaunchData.iMailboxId = FsMsgId(iPluginData, iMessageId.iFolderId.iMailboxId);
editorLaunchData.iFolderId = FsMsgId(iPluginData, iMessageId.iFolderId);
editorLaunchData.iMsgId = FsMsgId(iPluginData, iMessageId);
editorLaunchData.iActivatedExternally = ETrue;
TPckgBuf<TEditorLaunchParams> pckgData( editorLaunchData );
CVwsSessionWrapper* viewSrvSession = CVwsSessionWrapper::NewLC();
TUid command = TUid::Uid(KEditorCmdReplyAll);
if ( !aReplyToAll )
{
command = TUid::Uid(KEditorCmdReply);
}
viewSrvSession->ActivateView(TVwsViewId(KFSEmailUiUid, MailEditorId), command, pckgData);
CleanupStack::PopAndDestroy();
}
void CEmailMessage::ForwardMessageL()
{
TEditorLaunchParams editorLaunchData;
editorLaunchData.iExtra = NULL;
editorLaunchData.iMailboxId = FsMsgId(iPluginData, iMessageId.iFolderId.iMailboxId);
editorLaunchData.iFolderId = FsMsgId(iPluginData, iMessageId.iFolderId);
editorLaunchData.iMsgId = FsMsgId(iPluginData, iMessageId);
editorLaunchData.iActivatedExternally = ETrue;
TPckgBuf<TEditorLaunchParams> pckgData( editorLaunchData );
CVwsSessionWrapper* viewSrvSession = CVwsSessionWrapper::NewLC();
TUid command = TUid::Uid(KEditorCmdForward);
viewSrvSession->ActivateView(TVwsViewId(KFSEmailUiUid, MailEditorId), command, pckgData);
CleanupStack::PopAndDestroy();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TContentType::TContentType( const TDesC& aContentType ) : iContentType( aContentType )
{
_LIT( KSeparator, ";" );
TInt end = aContentType.Find( KSeparator );
if ( end != KErrNotFound )
{
iContentType.Set( aContentType.Left( end ) );
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TBool TContentType::Equals( const TDesC& aContentType )
{
TBool ret = iContentType.CompareF( aContentType );
if ( ret == 0 )
return ETrue;
else
return EFalse;
}
// End of file.