1 /*

     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *       SMTP MTM UI

    16 *

    17 */

    18 

    19 

    20 // MODULE - SMTP MTM UI

    21 

    22 // Standard includes

    23 #include <apacmdln.h>   //CApaCommandLine

    24 #include <apgcli.h>

    25 #include <apaid.h>

    26 #include <txtrich.h>    //CRichText

    27 #include <eikdialg.h>   //CEikDialog

    28 #include <eikenv.h>     //CEikonEnv

    29 #include <eikrutil.h>   //EikResourceUtils

    30 #include <MtmExtendedCapabilities.hrh>

    31 #include <akninputblock.h> // CAknInputBlock

    32 #include <StringLoader.h>

    33 #include <avkon.mbg> // bitmaps for progress

    34 #include <etelpckt.h>

    35 #include <aknViewAppUi.h> //CAknViewAppUi

    36 #include <eikapp.h>     //CEikApplication

    37 #include <aknclearer.h> // CAknLocalScreenClearer

    38 

    39 

    40 // SMTP & POP includes

    41 #include <smtcmtm.h>

    42 #include <smtpset.h>

    43 #include <pop3set.h>

    44 #include <imapset.h>

    45 #include <etel.h> // KErrEtelBusyDetected

    46 

    47 // Messaging includes

    48 #include <MuiuMsgEditorLauncher.h>

    49 #include <muiumsvuiserviceutilitiesinternal.h>

    50 #include <mtmuidef.hrh>

    51 #include <imum.rsg>

    52 #include <MuiuMsvProgressReporterOperation.h>

    53 #include <iapprefs.h>

    54 #include <ImumInternalApi.h>                        // CImumInternalApi

    55 

    56 // Specific includes

    57 #include "SmtpMtmUi.h"

    58 #include "ImumMtmLogging.h"

    59 #include "ImumPanic.h"

    60 #include <imum.rsg>

    61 #include "EmailPreCreation.h"

    62 #include "SmtpCreateNewOp.h"

    63 #include "SmtpCancelSendingOp.h"

    64 #include "SmtpCopyMoveOp.h"

    65 #include "SmtpResetPreCreationOp.h"

    66 

    67 #include "EmailFeatureUtils.h"

    68 #include "EmailUtils.H"

    69 #include "MsvEmailConnectionProgressProvider.h"

    70 #include "EmailEditorViewerUids.h"

    71 

    72 #include "SenduiMtmUids.h"

    73 #include "ComDbUtl.h"

    74 

    75 #include <Muiumsginfo.h>

    76 #include <Muiumsginfo.hrh>

    77 #include <MuiuOperationWait.h> // CMuiuOperationWait

    78 #include <messagingvariant.hrh>

    79 #include "IMSSettingsNoteUi.h"

    80 #include <ImumInSettingsData.h>             // CImumInSettingsData

    81 #include <ImumInSettingsDataCollection.h>   // CImumInSettingsDataCollection

    82 #include <ImumInMailboxServices.h>          // MImumInMailboxServices

    83 #include <ImumInHealthServices.h>           // MImumInHealthServices

    84 #include "ImumMboxSettingsUtils.h"          // ImumMboxSettingsUtils

    85 #include "ImumCreatorPredefinedMailbox.h"   // CImumCreatorPredefinedMailbox

    86 

    87 // CONSTANTS

    88 const TInt KImumEntriesDoneReplaceIndex     = 0;

    89 const TInt KImumTotalEntriesReplaceIndex    = 1;

    90 const TInt KImumMessageInfoDateBufferLength = 30;

    91 const TInt KImumMessageInfoSizeBufferLength = 20;

    92 const TInt KImumMessagePriorityBufferLength = 32;

    93 _LIT(KSmtpuMtmUiResourceFile,"IMUM");

    94 

    95 const TUid KMceMessageListViewId    = { 0x02 };

    96 const TUid KMceMainViewListViewId   = { 0x01 };

    97 const TInt KMceUid = 0x100058C5;

    98 

    99 // ----------------------------------------------------------------------------

   100 // CSmtpMtmUi::NewSMTUMtmUiL()

   101 // ----------------------------------------------------------------------------

   102 EXPORT_C CBaseMtmUi* NewSMTUMtmUiL(CBaseMtm& aMtm, CRegisteredMtmDll& aRegisteredDll)

   103     {

   104     return CSmtpMtmUi::NewL(aMtm, aRegisteredDll);

   105     }

   106 

   107 // ----------------------------------------------------------------------------

   108 // CSmtpMtmUi::NewL()

   109 // ----------------------------------------------------------------------------

   110 CSmtpMtmUi* CSmtpMtmUi::NewL(CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll)

   111     {

   112     IMUM_STATIC_CONTEXT( CSmtpMtmUi::NewL, 0, mtm, KImumMtmLog );

   113     IMUM_IN();

   114 

   115     CSmtpMtmUi* self=new(ELeave) CSmtpMtmUi(aBaseMtm, aRegisteredMtmDll);

   116     CleanupStack::PushL(self);

   117     self->ConstructL();

   118     CleanupStack::Pop();

   119     IMUM_OUT();

   120     return self;

   121     }

   122 

   123 // ----------------------------------------------------------------------------

   124 // CSmtpMtmUi::CSmtpMtmUi()

   125 // ----------------------------------------------------------------------------

   126 CSmtpMtmUi::CSmtpMtmUi(CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll)

   127     :

   128     CImumMtmBaseMtmUi( aBaseMtm, aRegisteredMtmDll )

   129     {

   130     IMUM_CONTEXT( CSmtpMtmUi::CSmtpMtmUi, 0, KImumMtmLog );

   131     IMUM_IN();

   132 

   133     //don't wait for msg editors to exit.

   134     iFlags = EMtmUiFlagEditorNoWaitForExit;

   135     IMUM_OUT();

   136     }

   137 

   138 // ----------------------------------------------------------------------------

   139 // CSmtpMtmUi::ConstructL()

   140 // ----------------------------------------------------------------------------

   141 void CSmtpMtmUi::ConstructL()

   142     {

   143     IMUM_CONTEXT( CSmtpMtmUi::ConstructL, 0, KImumMtmLog );

   144     IMUM_IN();

   145 

   146     // Construct own base MTM UI

   147     CImumMtmBaseMtmUi::ConstructL();

   148 

   149     // Create a 'message pre-creator'.

   150     iPreCreate = CEmailPreCreation::NewL( *iMailboxApi );

   151 

   152     //VARIATION START

   153     iNewSecureSettingOn =

   154         MsvEmailMtmUiFeatureUtils::LocalFeatureL(

   155             KCRUidMuiuVariation, KMuiuEmailConfigFlags,

   156             KEmailFeatureIdSecureSettings );

   157     //VARIATION END

   158     IMUM_OUT();

   159 

   160     }

   161 

   162 // ----------------------------------------------------------------------------

   163 // CSmtpMtmUi::ResolveEditorFileNameL()

   164 // ----------------------------------------------------------------------------

   165 void CSmtpMtmUi::ResolveEditorFileNameL()

   166     {

   167     IMUM_CONTEXT( CSmtpMtmUi::ResolveEditorFileNameL, 0, KImumMtmLog );

   168     IMUM_IN();

   169 

   170     __ASSERT_DEBUG(

   171         iEditorFilename == NULL,

   172             User::Panic(KImumMtmUiPanic, ESmtpMtmUiEditorFilenameDuplicate ) );

   173     iEditorFilename = MsvUiEditorUtilities::ResolveAppFileNameL(

   174         KUidMsgInternetMailEditor );

   175     IMUM_OUT();

   176     }

   177 

   178 // ----------------------------------------------------------------------------

   179 // CSmtpMtmUi::ResolveViewerFileNameL()

   180 // ----------------------------------------------------------------------------

   181 void CSmtpMtmUi::ResolveViewerFileNameL()

   182     {

   183     IMUM_CONTEXT( CSmtpMtmUi::ResolveViewerFileNameL, 0, KImumMtmLog );

   184     IMUM_IN();

   185 

   186     __ASSERT_DEBUG(

   187         iViewerFilename == NULL,

   188             User::Panic(KImumMtmUiPanic, ESmtpMtmUiEditorFilenameDuplicate ) );

   189     iViewerFilename = MsvUiEditorUtilities::ResolveAppFileNameL(

   190         KUidMsgInternetMailViewer );

   191     IMUM_OUT();

   192     }

   193 

   194 // ----------------------------------------------------------------------------

   195 // CSmtpMtmUi::GetResourceFileName()

   196 // ----------------------------------------------------------------------------

   197 void CSmtpMtmUi::GetResourceFileName( TFileName& aFileName ) const

   198     {

   199     IMUM_CONTEXT( CSmtpMtmUi::GetResourceFileName, 0, KImumMtmLog );

   200     IMUM_IN();

   201 

   202     aFileName=KSmtpuMtmUiResourceFile;

   203     IMUM_OUT();

   204     }

   205 

   206 // ----------------------------------------------------------------------------

   207 // CSmtpMtmUi::~CSmtpMtmUi()

   208 // ----------------------------------------------------------------------------

   209 CSmtpMtmUi::~CSmtpMtmUi()

   210     {

   211     IMUM_CONTEXT( CSmtpMtmUi::~CSmtpMtmUi, 0, KImumMtmLog );

   212     IMUM_IN();

   213 

   214     delete iPreCreate;

   215     iPreCreate = NULL;

   216     delete iEditorFilename;

   217     iEditorFilename = NULL;

   218     delete iViewerFilename;

   219     iViewerFilename = NULL;

   220     IMUM_OUT();

   221     }

   222 

   223 // ----------------------------------------------------------------------------

   224 // CSmtpMtmUi::QueryCapability()

   225 // ----------------------------------------------------------------------------

   226 TInt CSmtpMtmUi::QueryCapability(TUid aCapability, TInt& aResponse)

   227     {

   228     IMUM_CONTEXT( CSmtpMtmUi::QueryCapability, 0, KImumMtmLog );

   229     IMUM_IN();

   230 

   231     if ( aCapability.iUid == KUidMsvMtmUiQueryMessagingInitialisation )

   232         {

   233         aResponse=ETrue;

   234         IMUM_OUT();

   235         return KErrNone;

   236         }

   237     else if( aCapability.iUid == KUidMsvMtmQuerySupportValidateService )

   238         {

   239         aResponse=ETrue;

   240         IMUM_OUT();

   241         return KErrNone;

   242         }

   243     else if ( aCapability.iUid == KUidMsvMtmQuerySupportValidateSelection )

   244         {

   245         aResponse=ETrue;

   246         IMUM_OUT();

   247         return KErrNone;

   248         }

   249     else

   250         {

   251         IMUM_OUT();

   252         return CBaseMtmUi::QueryCapability( aCapability, aResponse );

   253         }

   254     }

   255 

   256 // ----------------------------------------------------------------------------

   257 // CSmtpMtmUi::InvokeAsyncFunctionL()

   258 // ----------------------------------------------------------------------------

   259 CMsvOperation* CSmtpMtmUi::InvokeAsyncFunctionL(

   260     TInt aFunctionId,

   261     const CMsvEntrySelection& aSelection,

   262     TRequestStatus& aStatus,

   263     TDes8& aParameter )

   264     {

   265     IMUM_CONTEXT( CSmtpMtmUi::InvokeAsyncFunctionL, 0, KImumMtmLog );

   266     IMUM_IN();

   267 

   268     if(aFunctionId == KMtmUiFunctionMessageInfo)

   269         {

   270         return ShowMessageInfoL(aStatus, aParameter);

   271         }

   272     if ( aFunctionId == KMtmUiFunctionPreCreateMessage )

   273         {

   274         CEmailPreCreation* preCreate = CEmailPreCreation::NewL( *iMailboxApi );

   275         CleanupStack::PushL( preCreate );

   276         CMsvOperation* op =

   277             preCreate->DeleteAllPreCreatedEmailsL( aSelection.At(0), aStatus );

   278         CleanupStack::PopAndDestroy( preCreate );

   279         IMUM_OUT();

   280 

   281         return op;

   282         }

   283     IMUM_OUT();

   284     return CBaseMtmUi::InvokeAsyncFunctionL( aFunctionId,

   285                                              aSelection,

   286                                              aStatus,

   287                                              aParameter);

   288     }

   289 

   290 // ----------------------------------------------------------------------------

   291 // CSmtpMtmUi::ShowMessageInfoL()

   292 // ----------------------------------------------------------------------------

   293 CMsvOperation* CSmtpMtmUi::ShowMessageInfoL(

   294     TRequestStatus& aCompletionStatus,

   295     TDes8& /*aParameter*/ )

   296     {

   297     IMUM_CONTEXT( CSmtpMtmUi::ShowMessageInfoL, 0, KImumMtmLog );

   298     IMUM_IN();

   299 

   300     TMsgInfoMessageInfoData infoData;

   301     TBuf<KImumMessageInfoDateBufferLength> dateBuf;

   302     TBuf<KImumMessageInfoDateBufferLength> timeBuf;

   303     TBuf<KImumMessageInfoSizeBufferLength> sizeBuf;

   304     TBuf<KImumMessagePriorityBufferLength> priorityBuf;

   305     MsvEmailMtmUiUtils::SetMessageInfoDataLCCCCC(

   306         infoData,BaseMtm(),

   307         *iEikonEnv,

   308         dateBuf,

   309         timeBuf,

   310         sizeBuf,

   311         priorityBuf

   312         );

   313 

   314     TBuf<KImumMessageInfoDateBufferLength> type;

   315     StringLoader::Load( type, R_SMTP_MESSAGE_INFO_MAIL_TYPE, iCoeEnv );

   316     infoData.iType.Set( type );

   317 

   318     CMsgInfoMessageInfoDialog* infoDialog = CMsgInfoMessageInfoDialog::NewL();

   319     infoDialog->ExecuteLD( infoData, CMsgInfoMessageInfoDialog::EEmailEditor );

   320     CleanupStack::PopAndDestroy( 5 ); // CSI: 47 # 5 C's on end of SetMessageInfoDataLCCCCC

   321     IMUM_OUT();

   322 

   323     return CMsvCompletedOperation::NewL(

   324         Session(),

   325         KUidMsvLocalServiceMtm,

   326         KNullDesC8,

   327         KMsvLocalServiceIndexEntryId,

   328         aCompletionStatus,

   329         KErrNone

   330         );

   331     }

   332 

   333 // ----------------------------------------------------------------------------

   334 // CSmtpMtmUi::InvokeSyncFunctionL()

   335 // ----------------------------------------------------------------------------

   336 void CSmtpMtmUi::InvokeSyncFunctionL(

   337     TInt aFunctionId,

   338     const CMsvEntrySelection& aSelection,

   339     TDes8& aParameter)

   340     {

   341     IMUM_CONTEXT( CSmtpMtmUi::InvokeSyncFunctionL, 0, KImumMtmLog );

   342     IMUM_IN();

   343 

   344     // Context is dependant on function ID.

   345 

   346     switch (aFunctionId)

   347         {

   348         case KMtmUiMessagingInitialisation:

   349             HandlePredefinedMailboxCreationL();

   350             break;

   351 

   352         case KMtmUiFunctionValidateService://servicevalidation

   353             ValidateServiceL( aParameter );

   354             break;

   355 

   356         case KUidMsvMtmQuerySupportValidateSelection:

   357             ValidateServiceL( aSelection, aParameter );

   358             break;

   359 

   360         default:

   361             CBaseMtmUi::InvokeSyncFunctionL(aFunctionId, aSelection, aParameter);

   362             break;

   363         };

   364     IMUM_OUT();

   365     }

   366 

   367 // ----------------------------------------------------------------------------

   368 // CSmtpMtmUi::CreateExecutePreCreationL()

   369 // ----------------------------------------------------------------------------

   370 //

   371 CMsvOperation* CSmtpMtmUi::CreateExecutePreCreationL(

   372     const TMsvId aSmtpService, TRequestStatus& aStatus ) const

   373     {

   374     IMUM_CONTEXT( CSmtpMtmUi::CreateExecutePreCreationL, 0, KImumMtmLog );

   375     IMUM_IN();

   376 

   377 

   378     if ( aSmtpService != KMsvNullIndexEntryId )

   379         {

   380         TMsvEntry mailbox = iUtils->GetMailboxEntryL( aSmtpService );

   381 

   382         // Precreate email only for regular mailboxes

   383         if ( iUtils->IsMailMtm( mailbox.iMtm ) )

   384             {

   385             // Create waiter operation and precreation operation

   386             CMsvOperation* op = CSmtpResetPreCreationOp::NewL(

   387                 iMailboxApi->MsvSession(), aStatus, aSmtpService );

   388             IMUM_OUT();

   389 

   390             return op;

   391             }

   392         }

   393     IMUM_OUT();

   394     return NULL;

   395     }

   396 

   397 // ----------------------------------------------------------------------------

   398 // CSmtpMtmUi::CreateEmailServiceL()

   399 // ----------------------------------------------------------------------------

   400 //

   401 CMsvOperation* CSmtpMtmUi::CreateEmailServiceL(

   402     const TMsvEntry& aEntry,

   403     TRequestStatus& aStatus )

   404     {

   405     IMUM_CONTEXT( CSmtpMtmUi::CreateEmailServiceL, 0, KImumMtmLog );

   406     IMUM_IN();

   407 

   408 

   409 

   410     // Prepare creation of the email

   411     TInt exitCode = KErrCancel; // JYKA: Changed from EEikCmdExit to allow proper error handling

   412     TSmtpMtmUiCreateNewServiceParameters saveParameters = ESmtpMtmUiCreateNewServiceExit;

   413     TMsvId smtpService = CreateNewServiceL( aEntry, saveParameters );

   414     CMsvOperation* preCreationOperation = NULL;

   415 

   416     // Return value decided the continuation

   417     switch ( saveParameters )

   418         {

   419         default:

   420         case ESmtpMtmUiCreateNewServiceNotCreated:

   421             exitCode = KErrCancel;

   422             break;

   423 

   424         case ESmtpMtmUiCreateNewServiceSave:

   425             preCreationOperation = CreateExecutePreCreationL( smtpService, aStatus );

   426             exitCode = KErrNone;

   427             break;

   428 

   429         case ESmtpMtmUiCreateNewServiceSaveAndExit:

   430             preCreationOperation = CreateExecutePreCreationL( smtpService, aStatus );

   431 

   432         //lint -fallthrough

   433         case ESmtpMtmUiCreateNewServiceExit:

   434             exitCode = EEikCmdExit;

   435             break;

   436         }

   437 

   438     IMUM_OUT();

   439 

   440     if ( preCreationOperation )

   441         {

   442         return preCreationOperation;

   443         }

   444 

   445     // Finally return the completed operation

   446     return CMsvCompletedOperation::NewL(

   447         Session(), Type(), KNullDesC8,

   448         KMsvLocalServiceIndexEntryId,

   449         aStatus, exitCode );

   450     }

   451 

   452 // ----------------------------------------------------------------------------

   453 // CSmtpMtmUi::CreateL()

   454 // ----------------------------------------------------------------------------

   455 CMsvOperation* CSmtpMtmUi::CreateL(

   456     const TMsvEntry& aEntry,

   457     CMsvEntry& /* aParent */,

   458     TRequestStatus& aStatus )

   459     {

   460     IMUM_CONTEXT( CSmtpMtmUi::CreateL, 0, KImumMtmLog );

   461     IMUM_IN();

   462 

   463 

   464     // Context is irrelevant.

   465     __ASSERT_ALWAYS( aEntry.iMtm==Type(),

   466         User::Panic(KImumMtmUiPanic, ESmtpMtmUiWrongMtm ) );

   467 

   468     TMsvId smtpService = KMsvNullIndexEntryId;

   469 

   470     // If service value provided, create the new mailbox

   471     if ( aEntry.iType.iUid == KUidMsvServiceEntryValue )

   472         {

   473 

   474         CMsvOperation* op = CreateEmailServiceL( aEntry, aStatus );

   475 

   476 

   477         IMUM_OUT();

   478 

   479         return op;

   480         }

   481     else if ( aEntry.iType.iUid != KUidMsvMessageEntryValue )

   482         {

   483         User::Leave( KErrNotSupported );

   484         }

   485 

   486     smtpService = aEntry.iServiceId;

   487     if( smtpService == KMsvNullIndexEntryId ||

   488         smtpService == KMsvUnknownServiceIndexEntryId )

   489         {

   490         // No accounts, offer to create one.

   491         TSmtpMtmUiCreateNewServiceParameters saveParameters;

   492         smtpService = HandleNoAccountsL( saveParameters );

   493         if(  saveParameters == ESmtpMtmUiCreateNewServiceNotCreated )

   494             {

   495 

   496             IMUM_OUT();

   497 

   498             // User cancelled.

   499             return CMsvCompletedOperation::NewL(

   500                 Session(), Type(), KNullDesC8,

   501                 KMsvLocalServiceIndexEntryId,

   502                 aStatus, KErrCancel);

   503             }

   504         else if(  saveParameters == ESmtpMtmUiCreateNewServiceExit )

   505             {

   506 

   507             IMUM_OUT();

   508 

   509             // User pressed Exit

   510             return CMsvCompletedOperation::NewL(

   511                 Session(), Type(),

   512                 KNullDesC8, KMsvLocalServiceIndexEntryId,

   513                 aStatus, EEikCmdExit);

   514             }

   515         }

   516     else

   517         {

   518 

   519         // Pass to the editor the service Id of the SMTP service to use to send the new message.

   520         // The message centre will pass a POP3 or IMAP4 service id in aEntry.iServiceId,

   521         // if so find the SMTP service associated with it.

   522         TMsvEntry entry;

   523         TInt findService = Session().GetEntry(aEntry.iServiceId, smtpService, entry);

   524         if ( findService == KErrNone )

   525             {

   526             if ( entry.iMtm != KUidMsgTypeSMTP )

   527                 {

   528                 // mce passed pop3 or imap4 service, so we need to find related smtp service

   529                 findService = Session().GetEntry(entry.iRelatedId, smtpService, entry);

   530                 }

   531             }

   532 

   533         if ( findService == KErrNotFound )

   534             {

   535 

   536             // this will dispay 'check email settings' note

   537             User::Leave( KSmtpUnknownErr );

   538             }

   539         else

   540             {

   541             User::LeaveIfError( findService );

   542             }

   543 

   544 

   545         //smtp auth fix 23092002

   546         CheckAndRestoreSmtpUserAndPasswordL( smtpService );

   547         //fix end

   548         }

   549 

   550 

   551     TEditorParameters editorParams;

   552     editorParams.iFlags |= EMsgCreateMessageToService;

   553     editorParams.iId = smtpService;

   554     TPckgC<TInt> paramPack(ESmtpMtmUiEditing);

   555     if(!iEditorFilename)

   556         ResolveEditorFileNameL();

   557     const TUint preferences = Preferences();

   558     editorParams.iFlags &= ~(EMsgLaunchEditorEmbedded | EMsgLaunchEditorThenWait);

   559     if(preferences & EMtmUiFlagEditorPreferEmbedded)

   560         {

   561         editorParams.iFlags |= EMsgLaunchEditorEmbedded;

   562         }

   563     if(!(preferences & EMtmUiFlagEditorNoWaitForExit))

   564         {

   565         editorParams.iFlags |= EMsgLaunchEditorThenWait;

   566         }

   567 

   568     IMUM_OUT();

   569 

   570     return CSmtpCreateNewOp::NewL(*iMailboxApi, aStatus, editorParams, *iEditorFilename, paramPack);

   571     }

   572 

   573 // ----------------------------------------------------------------------------

   574 // CSmtpMtmUi::OpenL()

   575 // ----------------------------------------------------------------------------

   576 CMsvOperation* CSmtpMtmUi::OpenL(TRequestStatus& aStatus)

   577     {

   578     IMUM_CONTEXT( CSmtpMtmUi::OpenL, 0, KImumMtmLog );

   579     IMUM_IN();

   580 

   581     // Context is entry to open.

   582     const TMsvEntry& context=iBaseMtm.Entry().Entry();

   583     __ASSERT_ALWAYS(context.iMtm==Type(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiWrongMtm));

   584 

   585     const TUid type(context.iType);

   586     __ASSERT_ALWAYS(type!=KUidMsvFolderEntry, User::Panic(KImumMtmUiPanic, ESmtpMtmUiFoldersNotSupported));

   587 

   588     //check that message is not corrupted and open

   589     CMsvEntry& tmpEntry = iBaseMtm.Entry();

   590     TBool hasStore = tmpEntry.HasStoreL();

   591 

   592     if( hasStore )

   593         {

   594         IMUM_OUT();

   595         return EditL(aStatus);

   596         }

   597     else//if corrupt

   598         {

   599         User::Leave( KErrCorrupt );

   600         IMUM_OUT();

   601         return NULL;//execution never gets here...but complier will

   602         }

   603     }

   604 

   605 // ----------------------------------------------------------------------------

   606 // CSmtpMtmUi::OpenL()

   607 // ----------------------------------------------------------------------------

   608 CMsvOperation* CSmtpMtmUi::OpenL(TRequestStatus& aStatus, const CMsvEntrySelection& aSelection)

   609     {

   610     IMUM_CONTEXT( CSmtpMtmUi::OpenL, 0, KImumMtmLog );

   611     IMUM_IN();

   612 

   613     // Context is irrelevant.

   614     __ASSERT_ALWAYS(aSelection.Count(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiEmptySelection));

   615     iBaseMtm.Entry().SetEntryL(aSelection[0]);

   616     IMUM_OUT();

   617     return OpenL(aStatus);

   618     }

   619 

   620 // ----------------------------------------------------------------------------

   621 // CSmtpMtmUi::CloseL()

   622 // ----------------------------------------------------------------------------

   623 CMsvOperation* CSmtpMtmUi::CloseL(TRequestStatus& aStatus)

   624     {

   625     IMUM_CONTEXT( CSmtpMtmUi::CloseL, 0, KImumMtmLog );

   626     IMUM_IN();

   627 

   628     // Context is entry to close.

   629     __ASSERT_DEBUG(iBaseMtm.Entry().Entry().iMtm==Type(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiWrongMtm));

   630     __ASSERT_DEBUG(iBaseMtm.Entry().Entry().iType!=KUidMsvFolderEntry, User::Panic(KImumMtmUiPanic, ESmtpMtmUiFoldersNotSupported));

   631     // No explicit close of SMTP entries.

   632     CMsvCompletedOperation* op=CMsvCompletedOperation::NewL( Session(), Type(), KNullDesC8, KMsvLocalServiceIndexEntryId, aStatus);

   633     IMUM_OUT();

   634     return op;

   635     }

   636 

   637 // ----------------------------------------------------------------------------

   638 // CSmtpMtmUi::CloseL()

   639 // ----------------------------------------------------------------------------

   640 CMsvOperation* CSmtpMtmUi::CloseL(TRequestStatus& aStatus, const CMsvEntrySelection& aSelection)

   641     {

   642     IMUM_CONTEXT( CSmtpMtmUi::CloseL, 0, KImumMtmLog );

   643     IMUM_IN();

   644 

   645     // Context is irrelevant.

   646     __ASSERT_ALWAYS(aSelection.Count(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiEmptySelection));

   647     iBaseMtm.Entry().SetEntryL(aSelection.At(0));

   648     IMUM_OUT();

   649     return CloseL(aStatus);

   650     }

   651 

   652 // ----------------------------------------------------------------------------

   653 // CSmtpMtmUi::EditL()

   654 // ----------------------------------------------------------------------------

   655 CMsvOperation* CSmtpMtmUi::EditL(TRequestStatus& aStatus)

   656     {

   657     IMUM_CONTEXT( CSmtpMtmUi::EditL, 0, KImumMtmLog );

   658     IMUM_IN();

   659 

   660     // Context is entry to edit.

   661     __ASSERT_ALWAYS(iBaseMtm.Entry().Entry().iMtm==Type(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiWrongMtm));

   662     __ASSERT_DEBUG(iBaseMtm.Entry().Entry().iType!=KUidMsvFolderEntry, User::Panic(KImumMtmUiPanic, ESmtpMtmUiFoldersNotSupported));

   663 

   664     switch (iBaseMtm.Entry().Entry().iType.iUid)

   665         {

   666     case KUidMsvMessageEntryValue:

   667         IMUM_OUT();

   668         return LaunchEditorApplicationL(aStatus, EFalse, EFalse, iBaseMtm.Entry().Session() );

   669         //break;    // Unreachable

   670     case KUidMsvServiceEntryValue:

   671         IMUM_OUT();

   672         return LaunchSettingsDialogL(aStatus);

   673         //break;    // Unreachable

   674     default:

   675         User::Leave(KErrNotSupported);

   676         break;

   677         };

   678     IMUM_OUT();

   679     return NULL;    // Unreachable in practice.

   680     }

   681 

   682 // ----------------------------------------------------------------------------

   683 // CSmtpMtmUi::EditL()

   684 // ----------------------------------------------------------------------------

   685 CMsvOperation* CSmtpMtmUi::EditL(TRequestStatus& aStatus, const CMsvEntrySelection& aSelection)

   686     {

   687     IMUM_CONTEXT( CSmtpMtmUi::EditL, 0, KImumMtmLog );

   688     IMUM_IN();

   689 

   690     // Context is irrelevant.

   691     __ASSERT_ALWAYS(aSelection.Count(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiEmptySelection));

   692     iBaseMtm.Entry().SetEntryL(aSelection[0]);

   693     IMUM_OUT();

   694     return EditL(aStatus);

   695     }

   696 

   697 // ----------------------------------------------------------------------------

   698 // CSmtpMtmUi::ViewL()

   699 // ----------------------------------------------------------------------------

   700 CMsvOperation* CSmtpMtmUi::ViewL(TRequestStatus& aStatus)

   701     {

   702     IMUM_CONTEXT( CSmtpMtmUi::ViewL, 0, KImumMtmLog );

   703     IMUM_IN();

   704 

   705     // Context is message to view.

   706     __ASSERT_ALWAYS(iBaseMtm.Entry().Entry().iMtm==Type(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiWrongMtm));

   707     __ASSERT_ALWAYS(iBaseMtm.Entry().Entry().iType!=KUidMsvFolderEntry, User::Panic(KImumMtmUiPanic, ESmtpMtmUiFoldersNotSupported));

   708 

   709     IMUM_OUT();

   710     return LaunchEditorApplicationL(aStatus, ETrue, EFalse, Session());

   711     }

   712 

   713 // ----------------------------------------------------------------------------

   714 // CSmtpMtmUi::ViewL()

   715 // ----------------------------------------------------------------------------

   716 CMsvOperation* CSmtpMtmUi::ViewL(TRequestStatus& aStatus, const CMsvEntrySelection& aSelection)

   717     {

   718     IMUM_CONTEXT( CSmtpMtmUi::ViewL, 0, KImumMtmLog );

   719     IMUM_IN();

   720 

   721     // Context is irrelevant.

   722     __ASSERT_ALWAYS(aSelection.Count(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiEmptySelection));

   723     iBaseMtm.Entry().SetEntryL(aSelection[0]);

   724     IMUM_OUT();

   725     return ViewL(aStatus);

   726     }

   727 

   728 // ----------------------------------------------------------------------------

   729 // CSmtpMtmUi::CancelL()

   730 // ----------------------------------------------------------------------------

   731 CMsvOperation* CSmtpMtmUi::CancelL(TRequestStatus& aStatus, const CMsvEntrySelection& aSelection)

   732     {

   733     IMUM_CONTEXT( CSmtpMtmUi::CancelL, 0, KImumMtmLog );

   734     IMUM_IN();

   735 

   736     // Context is irrelevant.

   737     __ASSERT_ALWAYS(aSelection.Count(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiEmptySelection));

   738     IMUM_OUT();

   739     return CSmtpCancelSendingOp::NewL( *iMailboxApi, aStatus, aSelection.CopyL());

   740     }

   741 

   742 // ----------------------------------------------------------------------------

   743 // CSmtpMtmUi::CopyFromL()

   744 // ----------------------------------------------------------------------------

   745 CMsvOperation* CSmtpMtmUi::CopyFromL(const CMsvEntrySelection& /*aSelection*/, TMsvId /*aTargetId*/, TRequestStatus& /*aStatus*/)

   746     {

   747     IMUM_CONTEXT( CSmtpMtmUi::CopyFromL, 0, KImumMtmLog );

   748     IMUM_IN();

   749 

   750     User::Panic(KImumMtmUiPanic, ESmtpMtmUiCannotCopyOrMoveFromSmtpServiceOrFolder);

   751     IMUM_OUT();

   752     return NULL;

   753     }

   754 

   755 // ----------------------------------------------------------------------------

   756 // CSmtpMtmUi::MoveFromL()

   757 // ----------------------------------------------------------------------------

   758 CMsvOperation* CSmtpMtmUi::MoveFromL(const CMsvEntrySelection& /*aSelection*/, TMsvId /*aTargetId*/, TRequestStatus& /*aStatus*/)

   759     {

   760     IMUM_CONTEXT( CSmtpMtmUi::MoveFromL, 0, KImumMtmLog );

   761     IMUM_IN();

   762 

   763     User::Panic(KImumMtmUiPanic, ESmtpMtmUiCannotCopyOrMoveFromSmtpServiceOrFolder);

   764     IMUM_OUT();

   765     return NULL;

   766     }

   767 

   768 // ----------------------------------------------------------------------------

   769 // MoveToL()

   770 // ----------------------------------------------------------------------------

   771 CMsvOperation* CSmtpMtmUi::MoveToL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus)

   772     {

   773     IMUM_CONTEXT( CSmtpMtmUi::MoveToL, 0, KImumMtmLog );

   774     IMUM_IN();

   775     IMUM_OUT();

   776 

   777     return DoCopyMoveToL(aSelection, aStatus, ETrue);

   778     }

   779 

   780 // ----------------------------------------------------------------------------

   781 // CSmtpMtmUi::CopyToL()

   782 // ----------------------------------------------------------------------------

   783 CMsvOperation* CSmtpMtmUi::CopyToL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus)

   784     {

   785     IMUM_CONTEXT( CSmtpMtmUi::CopyToL, 0, KImumMtmLog );

   786     IMUM_IN();

   787     IMUM_OUT();

   788 

   789     return DoCopyMoveToL(aSelection, aStatus, EFalse);

   790     }

   791 

   792 // ----------------------------------------------------------------------------

   793 // CSmtpMtmUi::DoCopyMoveToL()

   794 // ----------------------------------------------------------------------------

   795 CMsvOperation* CSmtpMtmUi::DoCopyMoveToL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus, TBool aMoving)

   796     {

   797     IMUM_CONTEXT( CSmtpMtmUi::DoCopyMoveToL, 0, KImumMtmLog );

   798     IMUM_IN();

   799 

   800     // Context is service to send to.

   801     const TMsvEntry& context=BaseMtm().Entry().Entry();

   802     __ASSERT_ALWAYS(context.iMtm==Type(), User::Panic(KImumMtmUiPanic, ESmtpMtmUiWrongMtm));

   803     __ASSERT_ALWAYS(context.iType==KUidMsvServiceEntry, User::Panic(KImumMtmUiPanic, ESmtpMtmUiNotAService));

   804 

   805     //smtp auth fix 23092002

   806     CheckAndRestoreSmtpUserAndPasswordL( BaseMtm().Entry().EntryId() );

   807     //fix end

   808 

   809     TInt cc = aSelection.Count();

   810     if(!cc)

   811         {

   812         // Nothing to do.

   813         return CMsvCompletedOperation::NewL(Session(), Type(), KNullDesC8, KMsvLocalServiceIndexEntryId, aStatus);

   814         }

   815     // Iterate entries in selection and check them.

   816     TBool changed = EFalse;

   817     TMsvEntry entry;

   818     TMsvId id = KMsvNullIndexEntryId;

   819     User::LeaveIfError(Session().GetEntry(aSelection[0], id, entry));

   820     CMsvEntry* parent = Session().GetEntryL(entry.Parent());

   821     CleanupStack::PushL(parent);

   822     CMsvEntry* centry = Session().GetEntryL(entry.Id());

   823     CleanupStack::PushL(centry);

   824     while(cc--)

   825         {

   826         id = aSelection[cc];

   827         entry = parent->ChildDataL(id);

   828         if(entry.iServiceId != context.Id())

   829             {

   830             // If service ID does not match context, set to context ID.

   831             entry.iServiceId = context.Id();

   832             changed = ETrue;

   833             }

   834         if(entry.SendingState() == KMsvSendStateSuspended)

   835             {

   836             // If the entry is suspended, set it to scheduled, or it will not be sent.

   837             entry.SetSendingState(KMsvSendStateWaiting);

   838             changed = ETrue;

   839             }

   840         if(changed)

   841             {

   842             if(centry->EntryId() != entry.Id())

   843                 {

   844                 centry->SetEntryL(entry.Id());

   845                 }

   846             centry->ChangeL(entry);

   847             changed = EFalse;

   848             }

   849         }

   850     CleanupStack::PopAndDestroy(2, parent); // CSI: 47 # centry, parent.

   851 

   852     // Create send operation.

   853     CMsvProgressReporterOperation* reporter =

   854         CMsvProgressReporterOperation::NewL(

   855             EFalse,

   856             ETrue,

   857             Session(),

   858             aStatus,

   859             EMbmAvkonQgn_note_mail );

   860     CleanupStack::PushL(reporter);

   861     CMsvOperation* op = CSmtpCopyMoveOp::NewL(*iMailboxApi, reporter->RequestStatus(),

   862         *reporter, context.Id(), aSelection, aMoving);

   863     reporter->SetOperationL(op); // Takes immediate ownership

   864     CleanupStack::Pop();    // reporter

   865     IMUM_OUT();

   866     return reporter;

   867     }

   868 

   869 // ----------------------------------------------------------------------------

   870 // CSmtpMtmUi::DisplayProgressSummary()

   871 // ----------------------------------------------------------------------------

   872 TInt CSmtpMtmUi::DisplayProgressSummary(const TDesC8& aProgress) const

   873     {

   874     IMUM_CONTEXT( CSmtpMtmUi::DisplayProgressSummary, 0, KImumMtmLog );

   875     IMUM_IN();

   876 

   877     // Context is irrelevent.

   878     if( (!aProgress.Length()) || (aProgress.Size() == sizeof(TMsvLocalOperationProgress)) )

   879         {

   880         IMUM_OUT();

   881         return KErrCancel;

   882         }

   883 

   884     if( aProgress.Size() == sizeof(TMsvId) )

   885         {

   886         // reason for this is that for CImEmailOperation did not fill iMtm correctly (it was always 0)

   887         // and that caused that in mce app's CMceUi::DoOperationCompletedL leaves

   888         // when trying to create mtm for displaying progress summary and execution

   889         // never came here. Now CImEmailOperation sets its iMtm correctly and

   890         // now CMceUi::DoOperationCompletedL works correcly and execution comes here.

   891         // problem now is that how to make difference between imum's internal progress

   892         // and CImEmailOperation progress since CImEmailOperation's progress is just

   893         // TMsvId of the created mail message. This needs to be solved.

   894         IMUM_OUT();

   895         return KErrNone;

   896         }

   897 

   898 

   899     // First element of progress should be identifier of the operation type

   900     TPckgC<TInt> progressType(0);

   901     progressType.Set(aProgress.Left(sizeof(TInt)));

   902     if(progressType()==ESmtpMtmUiEditing)

   903         {

   904         IMUM_OUT();

   905         return KErrNone;

   906         }

   907 

   908     // SMTP MTM operations

   909     __ASSERT_ALWAYS(aProgress.Size() == sizeof(TImSmtpProgress), User::Panic(KImumMtmUiPanic, ESmtpMtmUiBadProgress));

   910     TPckgBuf<TImSmtpProgress> paramPack;

   911     paramPack.Copy(aProgress);

   912     const TImSmtpProgress& progress = paramPack();

   913     TInt err = progress.Error();

   914     if( err != KErrNone && err != KErrCancel && err != KErrGeneral &&

   915         err != KErrEtelBusyDetected && err != KErrAbort )

   916         {

   917         if( err == KErrGprsServicesNotAllowed )

   918             {

   919             err = KImskErrorActiveSettingIsDifferent;

   920             }

   921         TRAP_IGNORE( iErrorResolver->ShowGlobalErrorNoteL( err ) );

   922         }

   923     IMUM_OUT();

   924     return err;

   925     }

   926 

   927 // ----------------------------------------------------------------------------

   928 // CSmtpMtmUi::GetProgress()

   929 // ----------------------------------------------------------------------------

   930 TInt CSmtpMtmUi::GetProgress(

   931     const TDesC8& aProgress,

   932     TBuf<EProgressStringMaxLen>& aReturnString,

   933     TInt& aTotalEntryCount,

   934     TInt& aEntriesDone,

   935     TInt& aCurrentEntrySize,

   936     TInt& aCurrentBytesTrans) const

   937     {

   938     IMUM_CONTEXT( CSmtpMtmUi::GetProgress, 0, KImumMtmLog );

   939     IMUM_IN();

   940 

   941     aEntriesDone=0;

   942     aTotalEntryCount=0;

   943     aCurrentBytesTrans=0;

   944     aCurrentEntrySize=0;

   945     aReturnString.Zero();

   946 

   947     if( (!aProgress.Length()) ||

   948         (aProgress.Size() == sizeof(TMsvLocalOperationProgress)) )

   949         {

   950         IMUM_OUT();

   951         return KErrNone;

   952         }

   953 

   954     // First element of progress should be identifier of the operation type

   955     TPckgC<TInt> type( 0 );

   956     type.Set( aProgress.Left( sizeof( TInt ) ) );

   957     switch ( type() )

   958         {

   959         case ESmtpMtmUiEditing:

   960             IMUM_OUT();

   961             // Editor operation

   962             return KErrNone;

   963 

   964         case EUiProgTypeConnecting:

   965             IMUM_OUT();

   966             // Connecting progress

   967             return GetConnectionProgress(aProgress, aReturnString);

   968 

   969         default:

   970             break;

   971         }

   972 

   973     // SMTP MTM operations

   974     __ASSERT_ALWAYS(aProgress.Size() == sizeof(TImSmtpProgress), User::Panic(KImumMtmUiPanic, ESmtpMtmUiBadProgress));

   975     TPckgBuf<TImSmtpProgress> paramPack;

   976     paramPack.Copy(aProgress);

   977     const TImSmtpProgress& progress = paramPack();

   978 

   979     aTotalEntryCount = progress.SendTotal();

   980     aEntriesDone = Min(aTotalEntryCount, progress.MsgNo()+1);

   981     aCurrentEntrySize = progress.iSendFileProgress.iBytesToSend;

   982     aCurrentBytesTrans = progress.iSendFileProgress.iBytesSent;

   983 

   984     TInt err = progress.Error();

   985     switch(progress.Status())

   986         {

   987         case EMsgOutboxProgressSending:

   988             {

   989             TInt resId = (aTotalEntryCount == 1) ? (R_SMTP_SENDING_PROGRESS) : (R_SMTP_SENDING_PROGRESS_MULTIPLE);

   990             StringLoader::Load( aReturnString, resId, iCoeEnv);

   991             if ( aTotalEntryCount>1 )

   992                 {

   993                 TBuf<EProgressStringMaxLen> tempBuffer;

   994                 StringLoader::Format(

   995                     tempBuffer,

   996                     aReturnString,

   997                     KImumEntriesDoneReplaceIndex,

   998                     aEntriesDone );

   999                 StringLoader::Format(

  1000                     aReturnString,

  1001                     tempBuffer,

  1002                     KImumTotalEntriesReplaceIndex,

  1003                     aTotalEntryCount );

  1004                 }

  1005             err = progress.Error();

  1006             }

  1007             break;

  1008         case EMsgOutboxProgressWaiting:

  1009         case EMsgOutboxProgressConnecting:

  1010         default:

  1011             // Should not get any other statuses, get UI connection progress instead.

  1012             aReturnString.Zero();

  1013             break;

  1014         }

  1015     IMUM_OUT();

  1016     return err;

  1017     }

  1018 

  1019 // ----------------------------------------------------------------------------

  1020 // CSmtpMtmUi::GetConnectionProgress()

  1021 // ----------------------------------------------------------------------------

  1022 TInt CSmtpMtmUi::GetConnectionProgress(const TDesC8& aProgress, TBuf<EProgressStringMaxLen>& aReturnString) const

  1023     {

  1024     IMUM_CONTEXT( CSmtpMtmUi::GetConnectionProgress, 0, KImumMtmLog );

  1025     IMUM_IN();

  1026 

  1027     __ASSERT_ALWAYS(aProgress.Size() == sizeof(TMsvEmailConnectionProgress), User::Panic(KImumMtmUiPanic, ESmtpMtmUiBadProgress));

  1028     TPckgBuf<TMsvEmailConnectionProgress> paramPack;

  1029     paramPack.Copy(aProgress);

  1030     const TMsvEmailConnectionProgress& connectProgress = paramPack();

  1031 

  1032     MsvEmailMtmUiUtils::CreateConnectingToText( aReturnString,

  1033         Session(), connectProgress.iService );

  1034     IMUM_OUT();

  1035 

  1036     return KErrNone;

  1037     }

  1038 

  1039 // ----------------------------------------------------------------------------

  1040 // CSmtpMtmUi::DoExitL()

  1041 // ----------------------------------------------------------------------------

  1042 CMsvOperation* CSmtpMtmUi::DoExitL(

  1043     TRequestStatus& aStatus,

  1044     const TBool aIssueQuit )

  1045     {

  1046     IMUM_CONTEXT( CSmtpMtmUi::DoExitL, 0, KImumMtmLog );

  1047     IMUM_IN();

  1048 

  1049     TInt err = aIssueQuit ? EEikCmdExit : EEikCmdCanceled;

  1050     IMUM_OUT();

  1051 

  1052     // Nothing to do, so return a completed operation.

  1053     return CMsvCompletedOperation::NewL(

  1054         Session(), Type(), KNullDesC8,

  1055         KMsvLocalServiceIndexEntryId, aStatus, err );

  1056     }

  1057 

  1058 // ----------------------------------------------------------------------------

  1059 // CSmtpMtmUi::LaunchEditorApplicationL()

  1060 // ----------------------------------------------------------------------------

  1061 CMsvOperation* CSmtpMtmUi::LaunchEditorApplicationL(

  1062     TRequestStatus& aStatus,

  1063     TBool aReadOnly,

  1064     TBool aNewMsg,

  1065     CMsvSession& aSession,

  1066     TMsvId aNewMsgServiceId)

  1067     {

  1068     IMUM_CONTEXT( CSmtpMtmUi::LaunchEditorApplicationL, 0, KImumMtmLog );

  1069     IMUM_IN();

  1070 

  1071     // Context is irrelevant.

  1072 

  1073     // Create the parameters necessary for the editor

  1074     TEditorParameters editorParams;

  1075     TMsvEntry entry = BaseMtm().Entry().Entry();

  1076     if ( entry.Parent() != KMsvDraftEntryId )

  1077         {

  1078         aReadOnly = ETrue;

  1079         }

  1080     if (aReadOnly)

  1081         {

  1082         editorParams.iFlags|=EMsgReadOnly;

  1083         }

  1084 

  1085     if ( !aReadOnly )

  1086         {

  1087         // we are opening the editor, check that there is at least one mail service defined

  1088         TMsvId serviceId = entry.iServiceId;

  1089         TSmtpMtmUiCreateNewServiceParameters aSaveParameters;

  1090 

  1091         if ( !CheckMailboxesBeforeEditL( serviceId, aSaveParameters ) )

  1092             {

  1093             if ( aSaveParameters == ESmtpMtmUiCreateNewServiceExit )

  1094                 {

  1095                 return CMsvCompletedOperation::NewL(Session(), Type(), KNullDesC8, KMsvLocalServiceIndexEntryId, aStatus, EEikCmdExit );

  1096                 }

  1097             else

  1098                 {

  1099                 return CMsvCompletedOperation::NewL(Session(), Type(), KNullDesC8, KMsvLocalServiceIndexEntryId, aStatus);

  1100                 }

  1101             }

  1102         if ( serviceId != entry.iServiceId )

  1103             {

  1104             // service has been changed, change it to the entry too...

  1105             entry.iServiceId = serviceId;

  1106             BaseMtm().Entry().ChangeL( entry );

  1107             }

  1108         }

  1109 

  1110     if (aNewMsg)

  1111         {

  1112         // Creating new message. The EMsgCreateMessageToService flag specifies that

  1113         // editorParams.iId is the SMTP service to use for the message.

  1114         __ASSERT_DEBUG(aNewMsgServiceId != KMsvNullIndexEntryIdValue, User::Panic(KImumMtmUiPanic, ESmtpMtmUiNullNewMsgService));

  1115         editorParams.iFlags |= EMsgCreateMessageToService;

  1116         editorParams.iId = aNewMsgServiceId;

  1117         }

  1118     else

  1119         {

  1120         editorParams.iId=BaseMtm().Entry().EntryId();

  1121         }

  1122 

  1123     //

  1124     // --- This is a MTM UI operation only, so make an appropriate progress package ---

  1125     // --- Editor progress is blank, except for the opreation identifier ---

  1126     TPckgC<TInt> paramPack(ESmtpMtmUiEditing);

  1127     HBufC* appName = NULL;

  1128     if(aReadOnly)

  1129         {

  1130         if(!iViewerFilename)

  1131             ResolveViewerFileNameL();

  1132         appName = iViewerFilename;

  1133         }

  1134     else