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 *       CImap4MtmUiData - IMAP4 MTM Ui data layer base API

    16 *

    17 */

    18 

    19 

    20 #include <coemain.h>

    21 #include <mtmuidef.hrh>

    22 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

    23 #include <mtmdef.hrh>

    24 #else

    25 #include <mtmdef.hrh>

    26 #include <mtmuidsdef.hrh>

    27 #endif

    28 #include <mtclbase.h>

    29 #include <miutset.h>

    30 #include "impicmds.h"

    31 #include <imapcmds.h>

    32 #include <impcmtm.h>

    33 #include <miuthdr.h>

    34 #include <eikon.rsg>

    35 #include "ImumPanic.h"

    36 #include <imum.rsg>

    37 #include <muiu.mbg>

    38 #include "Imap4MtmUiData.h"

    39 #include <mtud.hrh>

    40 #include <MtmExtendedCapabilities.hrh>

    41 #include "EmailEditorViewerUids.h"

    42 #include <data_caging_path_literals.hrh>

    43 #include <AknsUtils.h>

    44 #include <AknsConstants.h>//skinned icon ids

    45 #include "ImumMtmLogging.h"

    46 

    47 // Constants

    48 const TInt KIMAP4MtmUdNumberOfZoomStates=2; // second one is mask!

    49 const TInt KImumImap4FirstBitmapIndex = EMbmMuiuQgn_prop_mce_remote_sub;

    50 const TInt KImumImap4LastBitmapIndex = EMbmMuiuQgn_prop_folder_sub_unsubs_new_mask;

    51 

    52 const TInt KIsSupported=0;

    53 _LIT(KIMAP4MtmUdResourceFile, "IMUM.RSC");

    54 // Correct path is added to literal when it is used.

    55 _LIT(KIMAP4MtmUdBitmapFile, "z:muiu.MBM");

    56 

    57 // ----------------------------------------------------------------------------

    58 // NewIMPIMtmUiDataLayerL

    59 // ----------------------------------------------------------------------------

    60 EXPORT_C CBaseMtmUiData* NewIMPIMtmUiDataLayerL(CRegisteredMtmDll& aRegisteredDll)

    61     {

    62     return CImap4MtmUiData::NewL(aRegisteredDll);

    63     }

    64 

    65 // ----------------------------------------------------------------------------

    66 // NewL

    67 // ----------------------------------------------------------------------------

    68 CImap4MtmUiData* CImap4MtmUiData::NewL(CRegisteredMtmDll& aRegisteredDll)

    69     {

    70     IMUM_STATIC_CONTEXT( CImap4MtmUiData::NewL, 0, mtm, KImumMtmLog );

    71     IMUM_IN();

    72     

    73     CImap4MtmUiData* self=new(ELeave) CImap4MtmUiData(aRegisteredDll);

    74     CleanupStack::PushL(self);

    75     self->ConstructL();

    76     CleanupStack::Pop(); //self

    77     IMUM_OUT();

    78     return self;

    79     }

    80 

    81 // ----------------------------------------------------------------------------

    82 // CImap4MtmUiData

    83 // ----------------------------------------------------------------------------

    84 CImap4MtmUiData::CImap4MtmUiData(CRegisteredMtmDll& aRegisteredDll)

    85     :   CBaseMtmUiData(aRegisteredDll)

    86     {

    87     IMUM_CONTEXT( CImap4MtmUiData::CImap4MtmUiData, 0, KImumMtmLog );

    88     IMUM_IN();

    89     IMUM_OUT();

    90     

    91     __DECLARE_NAME(_S("CImap4MtmUiData"));

    92     }

    93 

    94 // ----------------------------------------------------------------------------

    95 // ConstructL

    96 // ----------------------------------------------------------------------------

    97 void CImap4MtmUiData::ConstructL()

    98     {

    99     IMUM_CONTEXT( CImap4MtmUiData::ConstructL, 0, KImumMtmLog );

   100     IMUM_IN();

   101     

   102     CBaseMtmUiData::ConstructL();

   103 

   104     iLastResortIcon = new(ELeave) CArrayPtrFlat<CFbsBitmap>(1);

   105     CWsBitmap* bitmap = new(ELeave) CWsBitmap(iCoeEnv->WsSession());

   106     CleanupStack::PushL(bitmap);

   107     User::LeaveIfError( bitmap->Create(TSize(1, 1), iCoeEnv->ScreenDevice()->DisplayMode()) );

   108     iLastResortIcon->AppendL(bitmap);

   109     CleanupStack::Pop(); // bitmap

   110     IMUM_OUT();

   111     }

   112 

   113 // ----------------------------------------------------------------------------

   114 // ~CImap4MtmUiData

   115 // ----------------------------------------------------------------------------

   116 CImap4MtmUiData::~CImap4MtmUiData()

   117     {

   118     IMUM_CONTEXT( CImap4MtmUiData::~CImap4MtmUiData, 0, KImumMtmLog );

   119     IMUM_IN();

   120     

   121     if(iLastResortIcon)

   122         {

   123         iLastResortIcon->ResetAndDestroy();

   124         delete iLastResortIcon;

   125         }

   126     IMUM_OUT();

   127     }

   128 

   129 // ----------------------------------------------------------------------------

   130 // OperationSupportedL

   131 // ----------------------------------------------------------------------------

   132 TInt CImap4MtmUiData::OperationSupportedL(TInt aOperationId, const TMsvEntry& aContext) const

   133     {

   134     IMUM_CONTEXT( CImap4MtmUiData::OperationSupportedL, 0, KImumMtmLog );

   135     IMUM_IN();

   136     

   137     if (!CheckEntry(aContext))

   138         return R_EIK_TBUF_NOT_AVAILABLE;

   139 

   140     TInt returnValue=R_EIK_TBUF_NOT_AVAILABLE;

   141 

   142     switch (aOperationId)

   143         {

   144     case KMtmUiFunctionMessageInfo:

   145         if(aContext.iType==KUidMsvMessageEntry)

   146             returnValue=KIsSupported;

   147         break;

   148     case KIMAP4MTMConnect:

   149     case KIMAP4MTMConnectAndSynchronise:

   150     case KImpiMTMConnect:

   151     case KImpiMTMConnectAndSyncCompleteAfterConnection:

   152     case KImpiMTMConnectAndSyncCompleteAfterFolderSync:

   153     case KImpiMTMConnectAndSyncCompleteAfterDisconnection:

   154     case KImpiMTMRefreshFolderList:

   155         if(!aContext.Connected() && aContext.iType==KUidMsvServiceEntry)

   156             returnValue=KIsSupported;

   157         break;

   158     case KIMAP4MTMDisconnect:

   159         if(aContext.Connected())

   160             {

   161             if(aContext.iType==KUidMsvServiceEntry)

   162                 returnValue=KIsSupported;

   163             }

   164         else

   165             {

   166             returnValue=R_EIK_TBUF_NOT_AVAILABLE;

   167             }

   168         break;

   169     case KImpiMTMPurgeAttachment:

   170         if(aContext.iType==KUidMsvAttachmentEntry)

   171             returnValue=KIsSupported;

   172         break;

   173     case KImpiMTMSubscribedFolders:

   174         {

   175         returnValue=KIsSupported;

   176         }

   177         break;

   178     case KImpiMTMFetchAttachments:

   179     case KIMAP4MTMCancelBackgroundSynchronise:

   180     case KIMAP4MTMStartBatch:

   181     case KIMAP4MTMEndBatch:

   182     case KIMAP4MTMBusy:

   183     case KIMAP4MTMSelect:

   184     case KIMAP4MTMSynchronise:

   185     case KIMAP4MTMSyncTree:

   186     case KIMAP4MTMSyncSubscription:

   187     case KIMAP4MTMFullSync:

   188     case KIMAP4MTMLocalSubscribe:

   189     case KIMAP4MTMLocalUnsubscribe:

   190 

   191     case KMtmUiFunctionFetchAll:

   192     case KMtmUiFunctionFetchNew:

   193     case KMtmUiFunctionFetchSelected:

   194     case KMtmUiFunctionGetNew:

   195         returnValue=KIsSupported;

   196         break;

   197     default:

   198         __ASSERT_DEBUG( 0, User::Panic(KImumMtmUiPanic, EIMAP4MtmUdUnknownOperationId) );

   199         break;

   200         };

   201     IMUM_OUT();

   202     return returnValue;

   203     }

   204 

   205 

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

   207 // QueryCapability

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

   209 TInt CImap4MtmUiData::QueryCapability(TUid aCapability, TInt& aResponse) const

   210     {

   211     IMUM_CONTEXT( CImap4MtmUiData::QueryCapability, 0, KImumMtmLog );

   212     IMUM_IN();

   213     

   214     switch (aCapability.iUid)

   215         {

   216     // --- Supported valued capabilities ---

   217     case KUidMtmQueryMaxBodySizeValue:

   218     case KUidMtmQueryMaxTotalMsgSizeValue:

   219         aResponse=KMaxTInt;

   220         break;

   221     case KUidMsvMtmQueryEditorUidValue:

   222         aResponse=KUidMsgInternetMailEditorAppValue;

   223         break;

   224     case KUidMsvMtmQueryViewerUidValue:

   225         aResponse=KUidMsgInternetMailViewerAppValue;

   226         break;

   227 

   228     // --- Supported non-valued capabilities ---

   229     case KUidMtmQuerySupportedBodyValue:

   230     case KUidMtmQueryCanReceiveMsgValue:

   231     case KUidMtmQuerySupportAttachmentsValue:

   232     case KUidMsvMtmUiQueryConnectionOrientedServices:

   233     case KUidMtmQuerySupportsFolderValue:

   234     case KUidMsvMtmUiQueryExtendedOpenProgress:

   235     case KUidMsvMtmUiQueryExtendedGetMailProgress:

   236     case KUidMsvMtmUiQueryCanGetNew:

   237     case KMtmUiFunctionMessageInfo:

   238         aResponse=0;

   239         break;

   240     // --- Non-supported capabilities ---

   241     default:

   242         IMUM_OUT();

   243         return KErrNotSupported;

   244         };

   245     IMUM_OUT();

   246     return KErrNone;

   247     }

   248 

   249 // ----------------------------------------------------------------------------

   250 // ContextIcon

   251 // ----------------------------------------------------------------------------

   252 const CBaseMtmUiData::CBitmapArray& CImap4MtmUiData::ContextIcon(const TMsvEntry& aContext, TInt aStateFlags) const

   253     {

   254     IMUM_CONTEXT( CBaseMtmUiData::CBitmapArray, 0, KImumMtmLog );

   255     IMUM_IN();

   256     

   257     // Deferred loading of bitmaps.

   258     if(!iIconArrays->Count())

   259         {

   260         //workaround const with const_cast

   261         TRAPD( err, const_cast<CImap4MtmUiData*>(this)->CreateSkinnedBitmapsL( KIMAP4MtmUdNumberOfZoomStates ) );

   262         if(err != KErrNone)

   263             {

   264             // Failed to load

   265             IMUM_OUT();

   266             return *iLastResortIcon;

   267             }

   268 

   269         /*

   270         // --- Populate bitmap array ---

   271         TRAPD(err, CONST_CAST(CImap4MtmUiData*,this)->CreateBitmapsL(

   272             KIMAP4MtmUdNumberOfZoomStates,

   273             KIMAP4MtmUdBitmapFile,

   274             KImumImap4FirstBitmapIndex,

   275             KImumImap4LastBitmapIndex));

   276         if(err != KErrNone)

   277             {

   278             // Failed to load

   279             return *iLastResortIcon;

   280             }

   281             */

   282         }

   283 

   284     TInt retIndex=0;

   285 

   286     TMsvEmailEntry mailEntry = aContext;

   287 

   288     // Service; can include unread messages or not

   289     if (aContext.iType.iUid == KUidMsvServiceEntryValue)

   290         {

   291         retIndex = (aStateFlags & EMtudEntryStateOpen) ?

   292             EImumPropMceRemoteNewSub :

   293             EImumPropMceRemoteSub;

   294 

   295         }

   296     // Messages; normal, deleted, incomplete

   297     else if ( aContext.iType.iUid==KUidMsvMessageEntryValue )

   298         {

   299         if(EDisconnectedDeleteOperation == mailEntry.DisconnectedOperation())

   300             {

   301             retIndex = EImumPropMceMailFetReaDel;

   302             }

   303         else

   304             {

   305             if(!mailEntry.BodyTextComplete())

   306                 {

   307                 retIndex = aContext.Unread() ?

   308                     EImumPropMceMailUnfetUnread :

   309                     EImumPropMceMailUnfetRead;

   310                 }

   311             else

   312                 {

   313                 retIndex = aContext.Unread() ?

   314                     EImumPropMceMailFetUnread :

   315                     EImumPropMceMailFetRead;

   316                 }

   317             }

   318         }

   319     // Folders

   320     else

   321         {

   322         TBool hasNew = aStateFlags & EMtudEntryStateOpen;

   323         TBool hasSub = aStateFlags & EMtudEntryStateSubFolder;

   324 

   325         TMsvEmailEntry eEntry( aContext );

   326         TBool isSubbed = eEntry.LocalSubscription();

   327 

   328         if( hasSub )

   329             {

   330             if( hasNew )

   331                 {

   332                 if( isSubbed )

   333                     {

   334                     retIndex = EImumPropFolderSubSubsNew;

   335                     }//if

   336                 else

   337                     {

   338                     retIndex = EImumPropFolderSubUnsubsNew;

   339                     }//else

   340                 }//if

   341             else

   342                 {

   343                 if( isSubbed )

   344                     {

   345                     retIndex = EImumPropFolderSubSubs;

   346                     }//if

   347                 else

   348                     {

   349                     retIndex = EImumPropFolderSubSmall;

   350                     }//else

   351                 }//else

   352             }//if

   353         else

   354             {

   355             if( hasNew )

   356                 {

   357                 if( isSubbed )

   358                     {

   359                     retIndex = EImumPropFolderSubsNew;

   360                     }//if

   361                 else

   362                     {

   363                     retIndex = EImumPropFolderUnsubsNew;

   364                     }//else

   365                 }//if

   366             else

   367                 {

   368                 if( isSubbed )

   369                     {

   370                     retIndex = EImumPropFolderSubs;

   371                     }//if

   372                 else

   373                     {

   374                     retIndex = EImumPropFolderSmall;

   375                     }

   376                 }//else

   377             }//else

   378 

   379         }//else

   380     IMUM_OUT();

   381 

   382     return *iIconArrays->At( retIndex / KIMAP4MtmUdNumberOfZoomStates );

   383     }

   384 

   385 // ----------------------------------------------------------------------------

   386 // PopulateArraysL

   387 // ----------------------------------------------------------------------------

   388 void CImap4MtmUiData::PopulateArraysL()

   389     {

   390     IMUM_CONTEXT( CImap4MtmUiData::PopulateArraysL, 0, KImumMtmLog );

   391     IMUM_IN();

   392     

   393     // --- Read commands list from resource ---

   394     ReadFunctionsFromResourceFileL(R_IMAP4UD_FUNCTION_ARRAY);

   395     IMUM_OUT();

   396 

   397     // Defer bitmap loading until requested.

   398     }

   399 

   400 // ----------------------------------------------------------------------------

   401 // GetResourceFileName

   402 // ----------------------------------------------------------------------------

   403 void CImap4MtmUiData::GetResourceFileName(TFileName& aFileName) const

   404     {

   405     IMUM_CONTEXT( CImap4MtmUiData::GetResourceFileName, 0, KImumMtmLog );

   406     IMUM_IN();

   407     

   408     aFileName=KIMAP4MtmUdResourceFile;

   409     IMUM_OUT();

   410     }

   411 

   412 // ----------------------------------------------------------------------------

   413 // CanCreateEntryL

   414 // ----------------------------------------------------------------------------

   415 TBool CImap4MtmUiData::CanCreateEntryL(const TMsvEntry& aParent, TMsvEntry& aNewEntry, TInt& aReasonResourceId) const

   416     {

   417     IMUM_CONTEXT( CImap4MtmUiData::CanCreateEntryL, 0, KImumMtmLog );

   418     IMUM_IN();

   419     

   420     aReasonResourceId=R_EIK_TBUF_NOT_AVAILABLE;

   421     if (!CheckEntry(aNewEntry))

   422         {

   423         IMUM_OUT();

   424         return EFalse;

   425         }

   426 

   427     // --- Can create IMAP4 service

   428     if ((aNewEntry.iType.iUid==KUidMsvServiceEntryValue) && (aParent.Id()==KMsvRootIndexEntryId))

   429         {

   430         aReasonResourceId=0;

   431         IMUM_OUT();

   432         return ETrue;

   433         }

   434 

   435     aReasonResourceId=R_EIK_TBUF_NOT_AVAILABLE;

   436     IMUM_OUT();

   437     return EFalse;

   438     }

   439 

   440 // ----------------------------------------------------------------------------

   441 // CanOpenEntryL

   442 // ----------------------------------------------------------------------------

   443 TBool CImap4MtmUiData::CanOpenEntryL(const TMsvEntry& /*aContext*/, TInt& aReasonResourceId) const

   444     {

   445     IMUM_CONTEXT( CImap4MtmUiData::CanOpenEntryL, 0, KImumMtmLog );

   446     IMUM_IN();

   447     

   448     aReasonResourceId=R_EIK_TBUF_NOT_AVAILABLE;

   449     IMUM_OUT();

   450     return EFalse;

   451     }

   452 

   453 // ----------------------------------------------------------------------------

   454 // CanCloseEntryL

   455 // ----------------------------------------------------------------------------

   456 TBool CImap4MtmUiData::CanCloseEntryL(const TMsvEntry& /*aContext*/, TInt& aReasonResourceId) const

   457     {

   458     IMUM_CONTEXT( CImap4MtmUiData::CanCloseEntryL, 0, KImumMtmLog );

   459     IMUM_IN();

   460     

   461     aReasonResourceId=R_EIK_TBUF_NOT_AVAILABLE;

   462     IMUM_OUT();

   463     return EFalse;

   464     }

   465 

   466 // ----------------------------------------------------------------------------

   467 // CanViewEntryL

   468 // ----------------------------------------------------------------------------

   469 TBool CImap4MtmUiData::CanViewEntryL(const TMsvEntry& /*aContext*/, TInt& aReasonResourceId) const

   470     {

   471     IMUM_CONTEXT( CImap4MtmUiData::CanViewEntryL, 0, KImumMtmLog );

   472     IMUM_IN();

   473     

   474     aReasonResourceId=R_EIK_TBUF_NOT_AVAILABLE;

   475     IMUM_OUT();

   476     return EFalse;

   477     }

   478 

   479 // ----------------------------------------------------------------------------

   480 // CanEditEntryL

   481 // ----------------------------------------------------------------------------

   482 TBool CImap4MtmUiData::CanEditEntryL(const TMsvEntry& /*aContext*/, TInt& aReasonResourceId) const

   483     {

   484     IMUM_CONTEXT( CImap4MtmUiData::CanEditEntryL, 0, KImumMtmLog );

   485     IMUM_IN();

   486     

   487     aReasonResourceId=R_EIK_TBUF_NOT_AVAILABLE;

   488     IMUM_OUT();

   489     return EFalse;

   490     }

   491 

   492 // ----------------------------------------------------------------------------

   493 // CanDeleteFromEntryL

   494 // ----------------------------------------------------------------------------

   495 TBool CImap4MtmUiData::CanDeleteFromEntryL(const TMsvEntry& aContext, TInt& aReasonResourceId) const

   496     {

   497     IMUM_CONTEXT( CImap4MtmUiData::CanDeleteFromEntryL, 0, KImumMtmLog );

   498     IMUM_IN();

   499 

   500     aReasonResourceId=R_EIK_TBUF_NOT_AVAILABLE;

   501     if (!CheckEntry(aContext))

   502         {

   503         IMUM_OUT();

   504         return EFalse;

   505         }

   506 

   507     const TMsvEmailEntry& context=aContext;

   508 

   509     if(context.iType.iUid==KUidMsvMessageEntryValue &&

   510        context.DisconnectedOperation()==ENoDisconnectedOperations)

   511         {

   512         aReasonResourceId=0;

   513         IMUM_OUT();

   514         return ETrue;

   515         }

   516     IMUM_OUT();

   517 

   518     return EFalse;

   519     }

   520 

   521 // ----------------------------------------------------------------------------

   522 // CanUnDeleteFromEntryL

   523 // ----------------------------------------------------------------------------

   524 TBool CImap4MtmUiData::CanUnDeleteFromEntryL(const TMsvEntry& aContext, TInt& aReasonResourceId) const

   525     {

   526     IMUM_CONTEXT( CImap4MtmUiData::CanUnDeleteFromEntryL, 0, KImumMtmLog );

   527     IMUM_IN();

   528     

   529     // N.B. Current Message Centre implementation specifies that aContext is actually the entry

   530     // to be undeleted, not the parent.

   531     aReasonResourceId=R_EIK_TBUF_NOT_AVAILABLE;

   532     if (!CheckEntry(aContext))

   533         {

   534         IMUM_OUT();

   535         return EFalse;

   536         }

   537 

   538     const TMsvEmailEntry& context=aContext;

   539 

   540     if(context.iType.iUid==KUidMsvMessageEntryValue && context.DisconnectedOperation()==EDisconnectedDeleteOperation)

   541         {

   542         aReasonResourceId=0;

   543         IMUM_OUT();

   544         return ETrue;

   545         }

   546     IMUM_OUT();

   547 

   548     return EFalse;

   549     }

   550 

   551 // ----------------------------------------------------------------------------

   552 // CanCopyMoveFromEntryL

   553 // ----------------------------------------------------------------------------

   554 TBool CImap4MtmUiData::CanCopyMoveFromEntryL(const TMsvEntry& /*aContext*/, TInt& aReasonResourceId) const

   555     {

   556     IMUM_CONTEXT( CImap4MtmUiData::CanCopyMoveFromEntryL, 0, KImumMtmLog );

   557     IMUM_IN();

   558     

   559     aReasonResourceId=R_EIK_TBUF_NOT_AVAILABLE;

   560     IMUM_OUT();

   561     return EFalse;

   562     }

   563 

   564 // ----------------------------------------------------------------------------

   565 // CanCopyMoveToEntryL

   566 // ----------------------------------------------------------------------------

   567 TBool CImap4MtmUiData::CanCopyMoveToEntryL(const TMsvEntry& /*aContext*/, TInt& aReasonResourceId) const

   568     {

   569     IMUM_CONTEXT( CImap4MtmUiData::CanCopyMoveToEntryL, 0, KImumMtmLog );

   570     IMUM_IN();

   571     

   572     aReasonResourceId=R_EIK_TBUF_NOT_AVAILABLE;

   573     IMUM_OUT();

   574     return EFalse;

   575     }

   576 

   577 // ----------------------------------------------------------------------------

   578 // CanReplyToEntryL

   579 // ----------------------------------------------------------------------------

   580 TBool CImap4MtmUiData::CanReplyToEntryL(const TMsvEntry& aContext, TInt& aReasonResourceId) const

   581     {

   582     IMUM_CONTEXT( CImap4MtmUiData::CanReplyToEntryL, 0, KImumMtmLog );

   583     IMUM_IN();

   584     

   585     __ASSERT_DEBUG( aContext.iMtm == KUidMsgTypeIMAP4, User::Panic(KImumMtmUiPanic,  EIMAP4MtmUdWrongMtm ));

   586     if ( aContext.iMtm == KUidMsgTypeIMAP4

   587         && aContext.iType == KUidMsvMessageEntry )

   588         {

   589         IMUM_OUT();

   590         return ETrue;

   591         }

   592     else

   593         {

   594         aReasonResourceId = R_EIK_TBUF_NOT_AVAILABLE;

   595         IMUM_OUT();

   596         return EFalse;

   597         }

   598 

   599     }

   600 

   601 // ----------------------------------------------------------------------------

   602 // CanForwardEntryL

   603 // ----------------------------------------------------------------------------

   604 TBool CImap4MtmUiData::CanForwardEntryL(const TMsvEntry& aContext, TInt& aReasonResourceId) const

   605     {

   606     IMUM_CONTEXT( CImap4MtmUiData::CanForwardEntryL, 0, KImumMtmLog );

   607     IMUM_IN();

   608     

   609     __ASSERT_DEBUG( aContext.iMtm == KUidMsgTypeIMAP4, User::Panic(KImumMtmUiPanic,  EIMAP4MtmUdWrongMtm ));

   610     if ( aContext.iMtm == KUidMsgTypeIMAP4

   611         && aContext.iType == KUidMsvMessageEntry )

   612         {

   613         IMUM_OUT();

   614         return ETrue;

   615         }

   616     else

   617         {

   618         aReasonResourceId = R_EIK_TBUF_NOT_AVAILABLE;

   619         IMUM_OUT();

   620         return EFalse;

   621         }

   622     }

   623 

   624 // ----------------------------------------------------------------------------

   625 // CanDeleteServiceL

   626 // ----------------------------------------------------------------------------

   627 TBool CImap4MtmUiData::CanDeleteServiceL(const TMsvEntry& /*aService*/, TInt& aReasonResourceId) const

   628     {

   629     IMUM_CONTEXT( CImap4MtmUiData::CanDeleteServiceL, 0, KImumMtmLog );

   630     IMUM_IN();

   631     

   632     aReasonResourceId=R_EIK_TBUF_NOT_AVAILABLE;

   633     IMUM_OUT();

   634     return EFalse;

   635     }

   636 

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

   638 // CanCancelL

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

   640 TBool CImap4MtmUiData::CanCancelL(const TMsvEntry& /*aContext*/, TInt& /*aReasonResourceId*/) const

   641     {

   642     IMUM_CONTEXT( CImap4MtmUiData::CanCancelL, 0, KImumMtmLog );

   643     IMUM_IN();

   644     

   645     IMUM_OUT();

   646     // IMAP messages can never be sent, consequently can never be cancelled.

   647     return EFalse;

   648     }

   649 

   650 // ----------------------------------------------------------------------------

   651 // StatusTextL

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

   653 HBufC* CImap4MtmUiData::StatusTextL(const TMsvEntry& /*aContext*/) const

   654     {

   655     IMUM_CONTEXT( CImap4MtmUiData::StatusTextL, 0, KImumMtmLog );

   656     IMUM_IN();

   657     

   658     IMUM_OUT();

   659     // IMAP messages never have a status in the outbox.

   660     return HBufC::NewL(1);

   661     }

   662 

   663 // ----------------------------------------------------------------------------

   664 // CheckEntry

   665 // ----------------------------------------------------------------------------

   666 TBool CImap4MtmUiData::CheckEntry(const TMsvEntry& aContext) const

   667     {

   668     IMUM_CONTEXT( CImap4MtmUiData::CheckEntry, 0, KImumMtmLog );

   669     IMUM_IN();

   670     IMUM_OUT();

   671     

   672     return  (aContext.iMtm==KUidMsgTypeIMAP4) ;

   673     }

   674 

   675 // ----------------------------------------------------------------------------

   676 // CreateSkinnedBitmapsL

   677 // ----------------------------------------------------------------------------

   678 void CImap4MtmUiData::CreateSkinnedBitmapsL( TInt aNumZoomStates )

   679     {

   680     IMUM_CONTEXT( CImap4MtmUiData::CreateSkinnedBitmapsL, 0, KImumMtmLog );

   681     IMUM_IN();

   682     

   683     MAknsSkinInstance* skins = AknsUtils::SkinInstance();

   684     TAknsItemID id;

   685     CFbsBitmap* bitmap;

   686     CFbsBitmap* bitmapMask;

   687     TBool found = ETrue;

   688 

   689     CBitmapArray* array = NULL;

   690 

   691 

   692     for( TInt i=KImumImap4FirstBitmapIndex; i<KImumImap4LastBitmapIndex+1; i++ )

   693         {

   694         found = ETrue;

   695         switch( i )

   696             {

   697             case EMbmMuiuQgn_prop_mce_remote_sub:

   698                 id.Set( KAknsIIDQgnPropMceRemoteSub );

   699                 break;

   700             case EMbmMuiuQgn_prop_mce_remote_new_sub:

   701                 id.Set( KAknsIIDQgnPropMceRemoteNewSub );

   702                 break;

   703             case EMbmMuiuQgn_prop_mce_mail_fet_rea_del:

   704                 id.Set( KAknsIIDQgnPropMceMailFetReaDel );

   705                 break;

   706             case EMbmMuiuQgn_prop_mce_mail_fet_read:

   707                 id.Set( KAknsIIDQgnPropMceMailFetRead );

   708                 break;

   709             case EMbmMuiuQgn_prop_mce_mail_fet_unread:

   710                 id.Set( KAknsIIDQgnPropMceMailFetUnread );

   711                 break;

   712             case EMbmMuiuQgn_prop_mce_mail_unfet_read:

   713                 id.Set( KAknsIIDQgnPropMceMailUnfetRead );

   714                 break;

   715             case EMbmMuiuQgn_prop_mce_mail_unfet_unread:

   716                 id.Set( KAknsIIDQgnPropMceMailUnfetUnread );

   717                 break;

   718             case EMbmMuiuQgn_prop_folder_small:

   719                 id.Set( KAknsIIDQgnPropFolderSmall );

   720                 break;

   721             case EMbmMuiuQgn_prop_folder_subs:

   722                 id.Set( KAknsIIDQgnPropFolderSubs );

   723                 break;

   724             case EMbmMuiuQgn_prop_folder_subs_new:

   725                 id.Set( KAknsIIDQgnPropFolderSubsNew );

   726                 break;

   727             case EMbmMuiuQgn_prop_folder_sub_small:

   728                 id.Set( KAknsIIDQgnPropFolderSubSmall );

   729                 break;

   730             case EMbmMuiuQgn_prop_folder_sub_subs:

   731                 id.Set( KAknsIIDQgnPropFolderSubSubs );

   732                 break;

   733             case EMbmMuiuQgn_prop_folder_sub_subs_new:

   734                 id.Set( KAknsIIDQgnPropFolderSubSubsNew );

   735                 break;

   736             case EMbmMuiuQgn_prop_folder_unsubs_new:

   737                 id.Set( KAknsIIDQgnPropFolderUnsubsNew );

   738                 break;

   739             case EMbmMuiuQgn_prop_folder_sub_unsubs_new:

   740                 id.Set( KAknsIIDQgnPropFolderSubUnsubsNew );

   741                 break;

   742             default:

   743                 found = EFalse;

   744                 break;

   745             }

   746 

   747         if( found )

   748             {

   749             array = new(ELeave) CArrayPtrFlat< CFbsBitmap >( aNumZoomStates );

   750             CleanupStack::PushL( array );

   751 

   752             TParse tp;

   753             tp.Set( KIMAP4MtmUdBitmapFile, &KDC_APP_BITMAP_DIR, NULL );

   754 

   755             AknsUtils::CreateIconL( skins, id, bitmap,

   756                 bitmapMask, tp.FullName(), i, i + 1 );

   757 

   758             array->AppendL( bitmap );

   759             array->AppendL( bitmapMask );

   760             iIconArrays->AppendL( array );

   761 

   762             CleanupStack::Pop();//array

   763             }

   764         }

   765     IMUM_OUT();

   766     }

   767 

   768 // End of File

   769