FCL/sf/app/commonemail: comparison emailservices/emailclientapi/src/emailmessage.cpp

equal deleted inserted replaced

-:d189ee25cf9d
+:3533d4323edc
 /*
-* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+* 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".
 #include "emailinterfacefactoryimpl.h"
 #include "emailcontent.h"
 #include "emailtextcontent.h"
 #include "emailmultipart.h"
 #include "emailattachment.h"
-#include "CFSMailPlugin.h"
+#include "cfsmailplugin.h"
-#include "CFSMailClient.h"
+#include "FreestyleEmailUiConstants.h"
+#include "cfsmailclient.h"
-#include <xqservicerequest.h>
-#include "email_services_api.h"
-const TInt KSendMessageRequestId = 100;
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 CEmailMessage* CEmailMessage::NewL( CPluginData& aPluginData,
 const TDataOwner aOwner )
 {
 CEmailMessage* message = new ( ELeave ) CEmailMessage( aPluginData, aFsMessage, aOwner );
 CleanupStack::PushL( message );
 message->ConstructL();
-CleanupStack::Pop( message );
+CleanupStack::Pop();
 return message;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 CEmailMessage::CEmailMessage(
 CPluginData& aPluginData,
 CFSMailMessage *aFsMessage,
 const TDataOwner aOwner)
 : iPluginData( aPluginData ), iPluginMessage( aFsMessage ), iOwner( aOwner )
 {
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMessage::ConstructL()
 {
-User::LeaveIfNull( iPluginMessage );
 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();
 // -----------------------------------------------------------------------------
 void CEmailMessage::Release()
 {
 if ( iOwner == EClientOwns )
 {
 delete this;
 }
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 const TMessageId& CEmailMessage::MessageId() const
 {
 return iMessageId;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailAddress* CEmailMessage::SenderAddressL() const
 {
-User::LeaveIfNull( iPluginMessage );
 CFSMailAddress* fsAddress = iPluginMessage->GetSender();
-if ( fsAddress )
+if (fsAddress)
 {
-if ( !iSender )
+if (!iSender)
 {
 iSender = CEmailAddress::NewL( MEmailAddress::ESender, EAPIOwns );
 }
 iSender->SetAddressL(fsAddress->GetEmailAddress());
 iSender->SetDisplayNameL(fsAddress->GetDisplayName());
 delete iSender;
 iSender = NULL;
 }
 return iSender;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailAddress* CEmailMessage::ReplyToAddressL() const
 {
-User::LeaveIfNull( iPluginMessage );
 const CFSMailAddress& fsAddress = iPluginMessage->GetReplyToAddress();
 if ( &fsAddress )
 {
-if ( !iReplyTo )
+if (!iReplyTo)
 {
 iReplyTo = CEmailAddress::NewL( MEmailAddress::EReplyTo, EAPIOwns );
 }
 iReplyTo->SetAddressL( fsAddress.GetEmailAddress() );
 iReplyTo->SetDisplayNameL( fsAddress.GetDisplayName() );
 delete iReplyTo;
 iReplyTo = NULL;
 }
 return iReplyTo;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMessage::SetReplyToAddressL( const MEmailAddress& aSender )
 {
-User::LeaveIfNull( iPluginMessage );
 CFSMailAddress *fsAddress = CFSMailAddress::NewLC();
-if ( !iReplyTo )
+if (!iReplyTo)
 {
-iReplyTo = CEmailAddress::NewL( MEmailAddress::EReplyTo, EAPIOwns );
+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 )
+aRole == MEmailAddress::ESender    )
 {
 User::Leave( KErrArgument );
 }
 else
 {
-User::LeaveIfNull( iPluginMessage );
 if( aRole == MEmailAddress::ETo ||
 aRole == MEmailAddress::EUndefined )
 {
-const RPointerArray<CFSMailAddress>& toRecipients =
+RPointerArray<CFSMailAddress>& toRecipients =
 iPluginMessage->GetToRecipients();
 ConvertAddressArrayL(
 MEmailAddress::ETo,
 toRecipients, aRecipients );
 }
 if( aRole == MEmailAddress::ECc ||
 aRole == MEmailAddress::EUndefined )
 {
-const RPointerArray<CFSMailAddress>& ccRecipients =
+RPointerArray<CFSMailAddress>& ccRecipients =
 iPluginMessage->GetCCRecipients();
 ConvertAddressArrayL(
 MEmailAddress::ECc,
 ccRecipients, aRecipients );
 }
 if( aRole == MEmailAddress::EBcc ||
 aRole == MEmailAddress::EUndefined )
 {
-const RPointerArray<CFSMailAddress>& bccRecipients =
+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() );
-User::LeaveIfNull( iPluginMessage );
 if( aRole == MEmailAddress::ETo )
 {
 iPluginMessage->AppendToRecipient( fsAddress );
 }
 else if( aRole == MEmailAddress::ECc )
 User::Leave( KErrArgument );
 }
 CleanupStack::Pop( fsAddress );
 }
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
-void CEmailMessage::RemoveRecipientL( const MEmailAddress& /*aRecipient*/ )
+void CEmailMessage::RemoveRecipientL( const MEmailAddress& aRecipient )
 {
-User::Leave( KErrNotSupported );
+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
 {
-if ( !iPluginMessage )
-return KNullDesC();
 return iPluginMessage->GetSubject();
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
-void  CEmailMessage::SetSubjectL( const TPtrC& aSubject )
+void  CEmailMessage::SetSubjectL( const TPtrC& aSubject)
 {
-User::LeaveIfNull( iPluginMessage );
 iPluginMessage->SetSubject( aSubject );
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 TTime CEmailMessage::Date() const
 {
-TTime time;
+return iPluginMessage->GetDate();
-if ( iPluginMessage ) {
-time = iPluginMessage->GetDate();
-}
-return time;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 void CEmailMessage::SetFlag( const TUint aFlag )
 {
 iFlags |= aFlag;
 TUint flag = MapFlags( aFlag );
-if ( iPluginMessage )
+iPluginMessage->SetFlag( flag );
-iPluginMessage->SetFlag( flag );
+}
-}
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMessage::ResetFlag( const TUint aFlag )
 {
 iFlags &= ~aFlag;
 TUint flag = MapFlags( aFlag );
-if ( iPluginMessage )
+iPluginMessage->ResetFlag( flag );
-iPluginMessage->ResetFlag( flag );
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMessage::InitializeFlagValues()
 {
-if ( !iPluginMessage )
-return;
 // 1st reset member value, then start copying different flags
 iFlags = 0;
 // EFlag_Read
 if ( iPluginMessage->IsFlagSet( EFSMsgFlag_Read ) )
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailMessageContent* CEmailMessage::ContentL() const
 {
-if ( iTextContent )
+if (iTextContent)
 {
 return iTextContent;
 }
-if ( iContent )
+if (iContent)
 {
 return iContent;
 }
-User::LeaveIfNull( iPluginMessage );
 RPointerArray<CFSMailMessagePart> parts;
 CleanupResetAndDestroyPushL( parts );
 iPluginMessage->ChildPartsL( parts );
 TInt count( parts.Count() );
 if( count == 0 )
 /* No content, return NULL */
 CleanupStack::PopAndDestroy( &parts ); // in case heap allocated but not used
 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 );
 parts[0] = NULL; // ownership of part transferred
 }
 iContent = CEmailMultipart::NewL(iPluginData, msgContentId, part, EAPIOwns);
 parts[0] = NULL; // ownership of part transferred
 }
 CleanupStack::PopAndDestroy( &parts ); // parts
 if (iTextContent)
 {
 return iTextContent;
 }
 return iContent;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMessage::SetContentL( const MEmailMessageContent*  aContent )
 {
-User::LeaveIfNull( aContent );
 MEmailTextContent* textContent = aContent->AsTextContentOrNull();
-if ( textContent )
+if (textContent)
 {
-if ( iTextContent )
+if (iTextContent)
 {
 delete iTextContent; // Destroy old content
 }
-iTextContent = dynamic_cast<CEmailTextContent*>( textContent );
+iTextContent = dynamic_cast<CEmailTextContent*>(textContent);
-if ( iTextContent )
+		if ( iTextContent )
-{
+			{
-iTextContent->SetOwner( EAPIOwns );
+			iTextContent->SetOwner( EAPIOwns );
-}
+			}
 return;
 }
 MEmailMultipart* mPart = aContent->AsMultipartOrNull();
-if ( mPart )
+if (mPart)
 {
-if ( iContent )
+if (iContent)
 {
 delete iContent;
 }
-iContent = dynamic_cast<CEmailMultipart*>( mPart );
+iContent = dynamic_cast<CEmailMultipart*>(mPart);
-if ( iContent )
+		if ( iContent )
-{
+			{
-iContent->SetOwner( EAPIOwns );
+			iContent->SetOwner( EAPIOwns );
-}
+			}
 }
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMessage::SetPlainTextBodyL( const TDesC& aPlainText )
 {
-if ( iTextContent )
+if (iTextContent)
 {
 iTextContent->SetTextL( MEmailTextContent::EPlainText, aPlainText );
 return;
 }
-User::LeaveIfNull( iPluginMessage );
 CFSMailMessagePart* msgTextPart = iPluginMessage->PlainTextBodyPartL();
 if( !msgTextPart )
 {
 msgTextPart = iPluginMessage->NewChildPartL( TFSMailMsgId(), KFSMailContentTypeTextPlain );
 }
 CleanupStack::PushL( msgTextPart );
-TMessageContentId msgContentId = MessageContentId( msgTextPart->GetPartId().Id() );
+TMessageContentId msgContentId = TMessageContentId(
+msgTextPart->GetPartId().Id(),
-msgTextPart->SetContentType( KFSMailContentTypeTextPlain );
+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 );
+CleanupStack::Pop(); // msgTextPart
 return;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailAttachment* CEmailMessage::AddAttachmentL( const TDesC& aFullPath )
 {
-User::LeaveIfNull( iPluginMessage );
+CFSMailMessagePart* part = iPluginMessage->AddNewAttachmentL(aFullPath, TFSMailMsgId());
-CFSMailMessagePart* part = iPluginMessage->AddNewAttachmentL( aFullPath, TFSMailMsgId() );
 CleanupStack::PushL( part );
-CEmailAttachment* att = CEmailAttachment::NewLC( iPluginData, iMsgContentId, part, EAPIOwns );
+CEmailAttachment* att = CEmailAttachment::NewLC(iPluginData, iMsgContentId, part, EAPIOwns);
 iAttachments.AppendL( att );
-CleanupStack::Pop( 2, part );
+CleanupStack::Pop(2); // part, att
 return att;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailAttachment* CEmailMessage::AddAttachmentL( RFile& aFile )
 {
-User::LeaveIfNull( iPluginMessage );
 TBufC8 <1> mime;
-CFSMailMessagePart* part = iPluginMessage->AddNewAttachmentL( aFile, mime );
+CFSMailMessagePart* part = iPluginMessage->AddNewAttachmentL(aFile, mime);
 CleanupStack::PushL( part );
-CEmailAttachment* att = CEmailAttachment::NewLC( iPluginData, iMsgContentId, part, EAPIOwns );
+CEmailAttachment* att = CEmailAttachment::NewLC(iPluginData, iMsgContentId, part, EAPIOwns);
 iAttachments.AppendL( att );
+CleanupStack::Pop(2); // part, att
-CleanupStack::Pop( 2, part );
 return att;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 TInt CEmailMessage::GetAttachmentsL( REmailAttachmentArray& aAttachments )
 {
-User::LeaveIfNull( iPluginMessage );
 RPointerArray<CFSMailMessagePart> attachments;
 CleanupResetAndDestroyPushL( attachments );
-iPluginMessage->AttachmentListL( attachments );
+iPluginMessage->AttachmentListL(attachments);
 const TInt count( attachments.Count() );
 for (TInt i = 0; i < count; i++)
 {
-TMessageContentId msgContentId = MessageContentId( attachments[i]->GetPartId().Id() );
+TMessageContentId msgContentId = TMessageContentId(
+attachments[i]->GetPartId().Id(),
-CEmailAttachment* att = CEmailAttachment::NewL(
+iMessageId.iId,
-iPluginData, msgContentId, attachments[i], EClientOwns );
+iMessageId.iFolderId.iId,
+iMessageId.iFolderId.iMailboxId );
-aAttachments.AppendL( att );
-}
+CEmailAttachment* att = CEmailAttachment::NewL(iPluginData, msgContentId, attachments[i], EClientOwns);
-CleanupStack::Pop( &attachments );
-return count;
+aAttachments.AppendL(att);
 }
+CleanupStack::Pop(); // attachments
-// -----------------------------------------------------------------------------
+return count;
-//
+}
-// -----------------------------------------------------------------------------
-void CEmailMessage::RemoveAttachmentL( const MEmailAttachment& /*aAttachment*/ )
+// -----------------------------------------------------------------------------
-{
+//
-User::Leave( KErrNotSupported );
+// -----------------------------------------------------------------------------
+void CEmailMessage::RemoveAttachmentL( const MEmailAttachment& aAttachment  )
+{
+iPluginMessage->RemoveChildPartL(FsMsgId( iPluginData, aAttachment.Id()));
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMessage::SaveChangesL()
 {
-User::LeaveIfNull( iPluginMessage );
 TFSMailMsgId mailboxId(
 FsMsgId( iPluginData, iMessageId.iFolderId.iMailboxId ) );
 iPlugin->StoreMessageL( mailboxId, *iPluginMessage );
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMessage::SendL()
 {
-User::LeaveIfNull( iPluginMessage );
-if ( iEventLoop.isRunning() )
-User::Leave( KErrInUse );
 SaveChangesL();
-iError = KErrNone;
+iPlugin->SendMessageL( *iPluginMessage );
-iPlugin->SendMessageL( *iPluginMessage, *this, KSendMessageRequestId );
+}
-iEventLoop.exec();
+// -----------------------------------------------------------------------------
-User::LeaveIfError( iError );
+//
-}
+// -----------------------------------------------------------------------------
+void CEmailMessage::ConvertAddressArrayL(
-// -----------------------------------------------------------------------------
-//
-// -----------------------------------------------------------------------------
-void CEmailMessage::RequestResponseL( TFSProgress aEvent, TInt aRequestId )
-{
-iError = aEvent.iError;
-if ( aRequestId == KSendMessageRequestId &&
-aEvent.iProgressStatus == TFSProgress::EFSStatus_RequestComplete )
-iEventLoop.quit();
-}
-// -----------------------------------------------------------------------------
-//
-// -----------------------------------------------------------------------------
-void CEmailMessage::ConvertAddressArrayL(
 const MEmailAddress::TRole aRole,
-const RPointerArray<CFSMailAddress>& aSrc,
+RPointerArray<CFSMailAddress>& aSrc,
 REmailAddressArray& aDst ) const
 {
 for ( TInt i=0; i<aSrc.Count(); i++ )
 {
 CEmailAddress* recipient = CreateAddressLC( aRole, *aSrc[i] );
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
-CEmailAddress* CEmailMessage::CreateAddressLC(
+//
+CEmailAddress* CEmailMessage::CreateAddressLC(
 const MEmailAddress::TRole aRole,
 CFSMailAddress& aFsAddress ) const
 {
 CEmailAddress* address = CEmailAddress::NewLC( aRole, EClientOwns );
 TDesC& temp1 = aFsAddress.GetEmailAddress();
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
+//
 TUint CEmailMessage::MapFlags( const TUint& aFlag )
 {
 TUint flag = 0;
 switch( aFlag )
 {
 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();
+}
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
-void CEmailMessage::ShowMessageViewerL()
-{
-bool syncronous;
-XQServiceRequest request(
-emailInterfaceNameMessage,
-emailOperationViewMessage,
-syncronous );
-TFSMailMsgId mailboxId = FsMsgId( iPluginData, iMessageId.iFolderId.iMailboxId );
-TFSMailMsgId folderId = FsMsgId( iPluginData, iMessageId.iFolderId );
-TFSMailMsgId messageId = FsMsgId( iPluginData, iMessageId );
-QList<QVariant> list;
-list.append( mailboxId.Id() );
-list.append( folderId.Id() );
-list.append( messageId.Id() );
-request.setArguments( list );
-QVariant returnValue;
-if ( !request.send( returnValue ) )
-User::Leave( KErrGeneral );
-}
-// -----------------------------------------------------------------------------
-// Launches Email application and new reply message in editor.
-// The method follows "fire and forget" pattern, returns immediately.
-// -----------------------------------------------------------------------------
-void CEmailMessage::ReplyToMessageL( const TBool /*aReplyToAll*/ )
-{
-User::Leave( KErrNotSupported );
-}
-// -----------------------------------------------------------------------------
 //
-// -----------------------------------------------------------------------------
-void CEmailMessage::ForwardMessageL()
-{
-User::Leave( KErrNotSupported );
-}
-// -----------------------------------------------------------------------------
-//
-// -----------------------------------------------------------------------------
-TMessageContentId CEmailMessage::MessageContentId( TEntryId aContentId ) const
-{
-TMessageContentId msgContentId = TMessageContentId(
-aContentId,
-iMessageId.iId,
-iMessageId.iFolderId.iId,
-iMessageId.iFolderId.iMailboxId );
-return msgContentId;
-}
-// -----------------------------------------------------------------------------
-//
-// -----------------------------------------------------------------------------
 TContentType::TContentType( const TDesC& aContentType ) : iContentType( aContentType )
 {
 _LIT( KSeparator, ";" );
 TInt end = aContentType.Find( KSeparator );
 if ( end != KErrNotFound )
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
+//
 TBool TContentType::Equals( const TDesC& aContentType )
 {
-TBool ret = iContentType.CompareF( aContentType );
+	TBool ret = iContentType.CompareF( aContentType );
 if ( ret == 0  )
-return ETrue;
+	return ETrue;
 else
-return EFalse;
+	return EFalse;
 }
-// End of file
+// End of file.

branch	RCL_3
changeset 64	3533d4323edc
parent 63	d189ee25cf9d