/*
* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  
*     Defines methods for CMceUi
*
*/




// INCLUDE FILES
#include <bldvariant.hrh>
#include <featmgr.h>

#include <messagingvariant.hrh>
#include <centralrepository.h>
#include <messaginginternalcrkeys.h>
#include <CoreApplicationUIsSDKCRKeys.h>

// security data caging
#include <data_caging_path_literals.hrh>

#include <mtudreg.h>        // cmtmuidataregistry
#include <MTMStore.h>       // cmtmstore
#include <miutset.h>
#include <MuiuMsvProgressReporterOperation.h> // cmsvprogressreporteroperation
#include <mtmdef.h>         // KUidMtmQueryCanSendMsgValue
#include <msvids.h>
#include <msvuids.h>
#include <mtud.hrh>         // EMtudCommandTransferSend, EMtudCommandTransferSend, EMtudCommandTransferReceive
#include <MuiuMessageIterator.h>// cmessageiterator
#include <MuiuMsgEmbeddedEditorWatchingOperation.h> // tmsgexitmode
#include <MuiuOperationWait.h>  // cmuiuoperationwait
#include <muiumsvuiserviceutilitiesinternal.h> // msvuiserviceutilitiesinternal
#include <MuiuMsvUiServiceUtilities.h> // msvuiserviceutilities
class CGulIcon;
#include <MsgFolderSelectionDialog.h>
#include <PushMtmCommands.hrh>    // epushmtmcmdcollectgarbage
#include <smutcmds.hrh>         // KMtmUiFunctionSmumRemoveSMSC
#include <MsgBioUids.h>     // kmsgbiouidpicturemsg
#include <mtuireg.h>        // CMtmUiRegistry
#include <mmsconst.h>
#include <obexclientmtm.h>
#include <MuiuOperationWait.h>  // cmuiuoperationwait
#include <muiu.mbg>
#include <muiu.rsg>
#include <MuiuMsvUiServiceUtilities.h>
#include <mtmuidef.hrh>

#include <SenduiMtmUids.h>      // mtm uids
#include <SendUiConsts.h>

// MMS.Content.Upload
#include <CSendingServiceInfo.h>
#include <sendui.h>
#include <CMessageData.h>


#include <aknappui.h>
#include <StringLoader.h>   // stringloader
#include <akntabgrp.h>
#include <aknnavide.h>
#include <aknclearer.h>
#include <aknnotewrappers.h>
#include <akninputblock.h> // cakninputblock
#include <akntitle.h>
#include <ErrorUI.h>        // cerrorui
#include <aknnotedialog.h>
#include <akninputblock.h> // cakninputblock
#include <akncontext.h>

#include <gfxtranseffect/gfxtranseffect.h>     // for transition effects
#include <akntranseffect.h>                    // for transition effects

#include <DocumentHandler.h>


#include <RCustomerServiceProfileCache.h>


// MMS.Content.Upload
#include <muiumsguploadparam.h>
#include <CSendingServiceInfo.h>

#include <ImumInternalApi.h>                // cimuminternalapi
#include <ImumInMailboxServices.h>          // mimuminmailboxservices
#include <ImumInSettingsData.h>             // cimuminsettingsdata
#include <ImumInSettingsKeys.h>             // timuminsettings
#include <UiklafInternalCRKeys.h>

#include <MNcnInternalNotification.h>
#include <NcnNotificationDefs.h>

#include <BTSapDomainPSKeys.h>
#include <e32property.h>

#include <muiulock.h>

#include <messaginginternalpskeys.h>        // kpsuidmuiu, kmuiukeycurrentmsg
#include <e32property.h>                    // RProperty

#include <CPhCltUssd.h>

#include <RPhCltServer.h>

#include <hlplch.h>             // For HlpLauncher

// For Muiu split
#include <muiumsvuiserviceutilitiesinternal.h>

#include <ImumInternalApi.h>                // cimuminternalapi

#ifdef RD_MULTIPLE_DRIVE
#include <driveinfo.h>
#endif // RD_MULTIPLE_DRIVE

#include <mce.rsg>
#include "MceCommands.hrh"
#include "mceui.h"
#include "MceSessionHolder.h"
#include "MceMessageListView.h"
//#include "MceMessageListbox.h"
#include "MceMainViewListView.h"
#include <mcesettingsdialog.h>
#include <mcesettingsarrays.h>
#include "MceMessageListContainerBase.h"
//#include "MceMessageListContainer.h"
#include "MceMainViewListContainer.h"
#include "MceBitmapResolver.h"
#include "MceConnectMailboxTimer.h"
#include "MceSendOperation.h"
#include "McePanic.h"
#include "MceLogEngine.h"
#include "MceDeliveryReportView.h"
//#include "MceMessageListItemArray.h"
#include "MceMainViewListItemArray.h"
#include "MceIdleMtmLoader.h"
#include "MceNaviPaneFolderIndicator.h"
//#include "MceEmailEditorResetTimer.h"
#include "MceCancelSendingOperation.h"
#include "MceChangeFlagOperation.h"     // cmceremovenewflag
#include "MceEmailNotifHandler.h"
#include "MceAttachmentAddition.h"
#include "mceiaupdateutils.h"


#include <miutset.h>
#include <mtmuids.h>
#include <MessagingDomainCRKeys.h>
#include <mcesettingsemailsel.h>
#include <mtmuids.h>
#include <MessagingDomainCRKeys.h>
//CR:422-271
#include <mmscodecclient.h>
#include "mmsclient.h"
#include "mmsconst.h"
#include "e32cmn.h"
// CONSTANTS

const TInt KMceArrayGranularity                     = 4;
const TUid KMceCBSApplication                       = {0x101F4CD3};
const TInt KMceCBSApplicationStartView              = 2;

_LIT( KMceDirAndFile,"muiu.mbm" );
// CONSTANTS

const TInt KMceAnswerToLifeUniverseAndEverything    = 42;
const TInt KMceMaxFolderLength                      = 35;
const TInt KMceTextLength                           = 120;
    // Estimate disk value for move or copy
const TInt KMceDiskSpaceForMoveOrCopy = 65536;
const TInt KMceMaxDateString(12);  // _mm/dd/yyyy_
const TInt KMceOneMMSNotificationFailed                 = 1;

_LIT8 ( KMceMMSNotifOne8, "1" ); // 8 bit one

#define KMessagingCentreMainViewUid TVwsViewId( \
    TUid::Uid( KMceApplicationUidValue ), \
    TUid::Uid( KMceMainViewListViewIdValue ) )

#ifdef _DEBUG
_LIT( KPanicText, "Mce" );
const TInt KCRepositorySettingFailure = 1;
#endif

const TInt KMceProgressReporterThreshold = 10;

const TUid KMailTechnologyTypeUid = { 0x10001671 };

//cmail update
#define KUidMsgTypeFsMtmVal               0x2001F406
//CR:422-271
_LIT( KMmsMessageDumpDirectory, "C:\\Private\\1000484b\\mmsvar");
_LIT( KRootPath, "C:\\" );
const TInt KMmsCodecClientChunkSize = 1024;

// LOCAL FUNCTION PROTOTYPES

//  ==================== LOCAL FUNCTIONS ====================
//

GLDEF_C void Panic(TMceUiPanic aPanic)
    // Panic function
    {
    User::Panic(_L("Mce"), aPanic);
    }


// ================= MEMBER FUNCTIONS =======================


CMceUi::CMceUi()
    :CAknViewAppUi(),
    iMsgTypesWritePopup( KMceArrayGranularity ),
    iMsgTypesWriteSubmenu( KMceArrayGranularity ),
    iMsgTypesSettings( KMceArrayGranularity ),
    iOperations( KMsvSingleOpWatcherArrayGranularity ),
    iMceIAUpdate( NULL ),
    iMoveOrCopyMailOperation(-1),
    iHandleNewMsgToInbox ( EFalse ),
    iAnchorId( NULL ),
    iEmailClientIntegration(EFalse),
    iSelectableEmail(EFalse),
    iEmailFramework(EFalse)
    {
    iMceUiFlags.SetMceFlag( EMceUiFlagsExitOnMsvMediaAvailableEvent );
    }

CMceUi::~CMceUi()
    {
    MCELOGGER_ENTERFN("~CMceUi()");
    iCoeEnv->RemoveForegroundObserver( *this ); // CR : 401-1806
    delete iBitmapResolver;
    if(iMtmLoader)
        {
        iMtmLoader->Cancel();
        delete iMtmLoader;
        }

#ifdef _DEBUG
    MCELOGGER_WRITE_FORMAT("iOperations.Count = %d", iOperations.Count() );
    const TInt count = iOperations.Count();
    for ( TInt loop = 0; loop < count; loop++ )
        {
        MCELOGGER_WRITE_FORMAT("loop = %d", loop );
        MCELOGGER_WRITE_FORMAT("operation id = %d", iOperations[loop]->Operation().Id() );
        }
#endif
    iOperations.ResetAndDestroy();
    delete iMTMFunctionsArray;
    delete iUiRegistry;
    delete iEntry;
    delete iRootEntry;
    delete iMtmStore;
    delete iConnectMailboxTimer;
    if ( iSessionHolder )
        {
        // must not delete sessionholder, it will kill itself...
        iSessionHolder->RemoveClient();
        // must not delete iSession, session holder takes care of that
        }
    delete iMceLogEngine;
    delete iMessageIterator;
    delete iFolderIndicator;
    delete iTabsArray;
    delete iMMSNotifications;
    delete iDecoratedTabGroup;
    delete iMceErrorUi;
    delete iLocalScreenClearer;
    // iSession and iMceDeliveryView owned by iSessionHolder
    // don't delete iMessageTypesDlg, dialog will delete itself.
    delete iMailAccountItemArray;
    // MMS.Content.Upload
    iUploadServices.ResetAndDestroy();
    delete iEmailApi;
    delete iEmailNotifHandler;
    delete iCancelExitFlagOperation;
    delete iMceIAUpdate;

    if ( iIdArray )
        {
        delete iIdArray;
        iIdArray = NULL;
        }
    // close connection monitor
    if ( iAlwaysOnline )
        {
        iConnectionMonitor.Close();
        }

    // delete KPSUidMuiu property
    RProperty::Delete( KPSUidMuiu, KMuiuKeyCurrentMsg );
    if ( iFeatureMgrEnabled ) // CR : 401-1806
        {
    FeatureManager::UnInitializeLib();
		    iFeatureMgrEnabled = EFalse ; // CR : 401-1806
		    }
	if(iEncodeBuffer)
	{
		delete iEncodeBuffer;
	}
	iFs.Close();
		
    MCELOGGER_LEAVEFN("~CMceUi()");
    MCELOGGER_DELETE;
    }

void CMceUi::ConstructL()
    {
    MCELOGGER_CREATE
    MCELOGGER_ENTERFN("ConstructL()");
    MCELOGGER_WRITE_TIMESTAMP("Time: ");

    if ( AknLayoutUtils::MSKEnabled() )
        {
        BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible );
        }
    else
        {
        BaseConstructL( EAknEnableSkin | EAknSingleClickCompatible );
        }

    // SIM access profiles
    CheckSIMAccessProfileL();

    // security data caging
    TParse fp;
    fp.Set( KMceDirAndFile, &KDC_APP_BITMAP_DIR , NULL );
    iFilename = fp.FullName();

    FeatureManager::InitializeLibL();
    iFeatureMgrEnabled = ETrue ; // CR : 401-1806

    //check if 'Memory in use' -option is enabled in mce settings
    iMemoryInUse = MceUtils::MemoryInUseOptionL();

    iAlwaysOnline = AlwaysOnlineL();

    iCancelExitFlagOperation = CIdle::NewL( CActive::EPriorityIdle );

    // Are CSP bits supported
    iCsp = CspBitsL();
    iSessionHolder = CMceSessionHolder::NewL( *this );
    iSession = iSessionHolder->Session();

    RFs& fs=iEikonEnv->FsSession();
    TBool storeChanged = EFalse;
    TBool storeOnPhoneMemory = ETrue;
#ifdef RD_MULTIPLE_DRIVE
    TInt phoneDrive;
    // At this point, try avoid using any predefined numbers E.G. EDriveC
    // in order to increase the safety and code flexibility
    User::LeaveIfError( DriveInfo::GetDefaultDrive( DriveInfo:: EDefaultPhoneMemory, phoneDrive ) );
    TInt currentDrive = TInt( iSession->CurrentDriveL() );
    if ( currentDrive != phoneDrive )
#else
    if ( TInt(iSession->CurrentDriveL()) == EDriveE )
#endif //RD_MULTIPLE_DRIVE
        {
        storeOnPhoneMemory = EFalse;
        TBool storeMounted = EFalse;
        TRAPD( error, storeMounted = (*iSession).MessageStoreDrivePresentL( ) );
        TBool driveContainsStore = EFalse;
#ifdef RD_MULTIPLE_DRIVE
        TRAPD( error2, driveContainsStore = iSession->DriveContainsStoreL( currentDrive ) );        
#else
        TRAPD( error2, driveContainsStore = iSession->DriveContainsStoreL( EDriveE ) );
#endif // RD_MULTIPLE_DRIVE
        if ( error || !storeMounted || error2 || !driveContainsStore )
            {
            //change the message store to phone
            storeChanged = ETrue;

            //Change message store to phones internal memory(EDriveC)
            MsvUiServiceUtilitiesInternal::ChangeMessageStoreToPhoneL( *iSession );
            iMceUiFlags.ClearMceFlag( EMceUiFlagsExitOnMsvMediaAvailableEvent );
            }
        }

    iMTMFunctionsArray=new (ELeave) CMsgFuncArray( KMceArrayGranularity );

    iBitmapResolver = CMceBitmapResolver::NewL( iSession, *this, ETrue );

    CMceMainViewListView* mainView = CMceMainViewListView::NewL(
        iSession,
        *iSessionHolder,
        *iBitmapResolver );
    CleanupStack::PushL( mainView );
    AddViewL(mainView);     // transfer ownership to CAknAppUi
    CleanupStack::Pop( mainView );
    iMceMainView = mainView;
    SetDefaultViewL( *iMceMainView );
    SetMceViewActive( EMceMainViewActive );

    iMceLogEngine = CMceLogEngine::NewL();

    CEikStatusPane* sp = StatusPane();
    iNaviPane = (CAknNavigationControlContainer *)sp->ControlL(TUid::Uid(EEikStatusPaneUidNavi));

    // iMessageIterator created when opening the message

    // Create IMAP folder indicator

    CMceNaviPaneFolderIndicator* folder =
        CMceNaviPaneFolderIndicator::NewL( storeOnPhoneMemory, 0 );

    CAknNavigationDecorator* tmp = CAknNavigationDecorator::NewL( 
        iNaviPane, folder, CAknNavigationDecorator::ENotSpecified );

    CleanupStack::PushL( tmp );
    tmp->SetContainerWindowL( *iNaviPane );
    CleanupStack::Pop( tmp ); 
    tmp->MakeScrollButtonVisible( EFalse );
    iFolderIndicator = tmp;

    iMailAccountItemArray = new(ELeave) CMceMailAccountItemArray(
        KMceArrayGranularity );

    iMceIAUpdate = CMceIAUpdateUtils::NewL(*this);

    if ( iAlwaysOnline )
        {
        iConnectionMonitor.ConnectL();
        iConnectionMonitor.NotifyEventL( *this );
        }

    iMceUiFlags.SetMceFlag( EMceUiFlagsFinishedConstruction );

    if ( storeChanged )
        {
        // message store switching ate EMsvServerReady so do it once again,
        // when all has been constructed
        storeChanged = EFalse;
        HandleSessionEventL( MMsvSessionObserver::EMsvServerReady, NULL, NULL, NULL );
        }

    // Contents of uploadservices
    if ( FeatureManager::FeatureSupported(KFeatureIdSenduiMmsUpload) )
        {
        CSendUi* sendui = CSendUi::NewLC( );
        sendui->AvailableServicesL( iUploadServices, KMmsDirectUpload );
        sendui->AvailableServicesL( iUploadServices, KMmsIndirectUpload );
        CleanupStack::PopAndDestroy( sendui );
        }
    
    iAudioMsgEnabled = EFalse ; // CR : 401-1806
    iPostcardEnabled = EFalse ; // CR : 401-1806
    if ( FeatureManager::FeatureSupported( KFeatureIdEmailMceIntegration ) )
        {
        iEmailClientIntegration = ETrue;
        }
    if ( FeatureManager::FeatureSupported( KFeatureIdSelectableEmail ) )
        {
        iSelectableEmail = ETrue;
        }
    if ( FeatureManager::FeatureSupported( KFeatureIdFfEmailFramework ) )
        {
        iEmailFramework = ETrue;
        }
    iMsgDeletedStatus = EFalse;
    iServerStarted = EFalse ;
    iEmailNotifHandler = NULL;
#ifndef __WINSCW__ 
    // Handling of NCN reset
    TRAPD( err, iEmailNotifHandler = CMceEmailNotifHandler::NewL() );
    MCELOGGER_WRITE_FORMAT("ConstructL iEmailNotifHandler err %d", err);
    if ( err )
        {
        iEmailNotifHandler = NULL;
        }
#endif
    ZoomLevelChangedL( ReadZoomLevelL() );

    iEmailApi = CreateEmailApiL( iSession );

    SetDiskSpaceForMoveOrCopyL();
    //CR:422-271
	//initializing the encodebuffer for MMS templates   
    iEncodeBuffer = CBufFlat::NewL( 1 );//To remove hardcoding
    User::LeaveIfError( iFs.Connect() );
    iFs.SetSessionPath( KRootPath );

    MCELOGGER_LEAVEFN("ConstructL()");
    }

// ----------------------------------------------------
// CMceUi::HandleSessionEventL
// ----------------------------------------------------
void CMceUi::HandleSessionEventL(
    TMsvSessionEvent aEvent,
    TAny* aArg1,
    TAny* aArg2,
    TAny* /*aArg3*/ )
    {
    MCELOGGER_WRITE_TIMESTAMP("CMceUi::HandleSessionEventL() start");
    MCELOGGER_WRITE_FORMAT("aEvent=%d", aEvent);

    if ( !iMceUiFlags.MceFlag( EMceUiFlagsFinishedConstruction ) )
        {
        return;
        }

    TMsvId folderId = KMsvNullIndexEntryId;

    // ConstructL must have left as we have returned to the active scheduler
    // before complete construction
    TInt err;
    switch (aEvent)
        {
    case EMsvServerReady:
    case EMsvCorruptedIndexRebuilt:
        iMceUiFlags.ClearMceFlag( EMceUiFlagsMediaUnavailable );
        TRAP(err, HandleServerStartupL());
        if (err!=KErrNone)
            {
            // close...
            MCELOGGER_WRITE_FORMAT("HandleServerStartupL: %d", err);
            iMceUiFlags.SetMceFlag( EMceUiFlagsWantToExit );
            iCoeEnv->HandleError( err );
            Exit();
            }
         // Messaging application is started to background in bootup.
         // However messaging main view is not activated in background startup.
         // Because of that startup of messaging application after background startup is not as fast as other startups.
         // This can be optimized by activating main view same way than when messaging application is hide to background.
         if ( !IsForeground() )
            {
            HideOrExit();
            }        
        break;
    case EMsvMediaChanged:
    case EMsvMtmGroupInstalled:
    case EMsvMtmGroupDeInstalled:
        iMceUiFlags.ClearMceFlag( EMceUiFlagsMediaUnavailable );
        HandleMTMChangeL();
        break;
    case EMsvEntriesCreated:
    case EMsvEntriesDeleted:
        iMceUiFlags.ClearMceFlag( EMceUiFlagsMediaUnavailable );
        folderId = (*(TMsvId*) (aArg2));
        if ( folderId == KMsvRootIndexEntryId )
            {
            if ( IsPresent( KSenduiMtmSyncMLEmailUid ) )
                {
                // check if syncml item should be added/removed
                // in new message dialog
                SyncMlNewMessageItemL( (CMsvEntrySelection*) aArg1, aEvent );
                }
            // something changed in root i.e. mailbox created or deleted...
            RemoveTabsAndUpdateArray();
            }
        // fall through 
    case EMsvEntriesChanged:
        folderId = (*(TMsvId*) (aArg2));
        if ( folderId == KMsvRootIndexEntryId && iMceUiFlags.MceFlag( EMceUiFlagsTabsActive ) )
            {
            CMsvEntrySelection* selection = (CMsvEntrySelection*) aArg1; // do not take ownership
            const TInt count = selection->Count();
            TInt selectedIndex = KErrNotFound;
            for ( TInt loop = 0; loop < count && selectedIndex == KErrNotFound; loop++ )
                {
                selectedIndex = iTabsArray->Find( selection->At( loop ) );
                }

            if ( selectedIndex != KErrNotFound )
                {
                CheckRemoteMailboxTabIconsL();
                }
            }
        // list update done by active view so do nothing here
        break;
    case EMsvServerFailedToStart:
    case EMsvServerTerminated:
    case EMsvCloseSession:
        iMceUiFlags.SetMceFlag( EMceUiFlagsWantToExit );
        iAvkonViewAppUi->ProcessCommandL( EAknCmdExit );
        break;
    case EMsvGeneralError:
        {
        const TInt leave=*STATIC_CAST(TInt*,aArg1);
        if (iMceUiFlags.MceFlag( EMceUiFlagsWantToExit ) && leave==KLeaveExit)
            {
            User::Leave(leave);
            }
        break;
        }
    case EMsvMediaUnavailable:
        iMceUiFlags.SetMceFlag( EMceUiFlagsMediaUnavailable );
        if ( iMceUiFlags.MceFlag( EMceUiFlagsExitOnMsvMediaAvailableEvent ) )
            {
            MCELOGGER_WRITE("CMceUi::HandleSessionEventL() EMsvMediaUnavailable EXIT");
            iMceUiFlags.SetMceFlag( EMceUiFlagsWantToExit );
            iAvkonViewAppUi->ProcessCommandL( EAknCmdExit );
            }
        else
            {
            MCELOGGER_WRITE("CMceUi::HandleSessionEventL() EMsvMediaUnavailable Clear flag!");
            iMceUiFlags.ClearMceFlag( EMceUiFlagsExitOnMsvMediaAvailableEvent );
            }
        break;
    case EMsvMediaAvailable:
        {
        iMceUiFlags.ClearMceFlag( EMceUiFlagsMediaUnavailable );
        iMceUiFlags.SetMceFlag( EMceUiFlagsExitOnMsvMediaAvailableEvent );
        // update folders tab
        CMceNaviPaneFolderIndicator* findicator =
            static_cast<CMceNaviPaneFolderIndicator*>( iFolderIndicator->DecoratedControl() );
        findicator->ChangeRootL( TInt(iSession->CurrentDriveL() == EDriveC) );
        }
        // fall through 
    default:
        break;
        }
    MCELOGGER_WRITE_TIMESTAMP("CMceUi::HandleSessionEventL() end");
    }

// ----------------------------------------------------
// CMceUi::HandleServerStartupL
// ----------------------------------------------------
void CMceUi::HandleServerStartupL()
    {
    iServerStarted = EFalse ;
    LoadContextIconL();

    if ( iMceUiFlags.MceFlag( EMceUiFlagsServerReady ) )
        {
        MCELOGGER_LEAVEFN("HandleServerStartupL(), server ready");

        if ( iMemoryInUse )
            {
            // when iSession->ChangeDriveL is called, also HandleSessionEvent is called
            // using EMsvServerReady

            if(iMtmLoader)
                {
                iMtmLoader->Cancel();
                delete iMtmLoader;
                iMtmLoader = NULL;
                }

            delete iUiRegistry;
            iUiRegistry=NULL;

            delete iEntry;
            iEntry = NULL;
            iEntry=iSession->GetEntryL(KMsvRootIndexEntryId);

            delete iRootEntry;
            iRootEntry = NULL;
            iRootEntry=CMsvEntry::NewL(
                *iSession,
            KMsvRootIndexEntryId,
            TMsvSelectionOrdering(KMsvNoGrouping, EMsvSortByNone, ETrue));

            delete iMtmStore;
            iMtmStore=NULL;

            iMtmStore=CMtmStore::NewL(*iSession);
            iUiRegistry=CMtmUiDataRegistry::NewL(*iSession);

            iRootEntry->SetEntryL(KMsvRootIndexEntryIdValue);

            // reconstruct main view
            iMceMainView->ConstructMainViewL();

            // reconstruct tabs
            TBool tabsActive = iMceUiFlags.MceFlag( EMceUiFlagsTabsActive );
            RemoveTabs();
            delete iDecoratedTabGroup;
            iDecoratedTabGroup = NULL;
            delete iTabsArray;
            iTabsArray = NULL;

            if ( MceViewActive( EMceMessageViewActive ) 
                && tabsActive 
                && ( !iMceListView->IsImapFolderOpenL( ) ) )
                {
                const TMceListItem& tempItem = iMceMainView
                    ->ListContainer()->CurrentItemListItem();
                TMsvId service;
                TMsvEntry child;
                User::LeaveIfError( iSession->GetEntry( tempItem.iMsvId, service, child ) );
                ShowTabsL( child.Id() );
                }

            // update folders tab
            CMceNaviPaneFolderIndicator* findicator =
                static_cast<CMceNaviPaneFolderIndicator*>( iFolderIndicator->DecoratedControl() );
            findicator->ChangeRootL( TInt(iSession->CurrentDriveL()) );

            iMceMainView->ListContainer()->DrawNow();
            }
        iServerStarted = ETrue ;
        return;
        }

    iEntry=iSession->GetEntryL(KMsvRootIndexEntryId);
    iRootEntry=CMsvEntry::NewL(
        *iSession,
        KMsvRootIndexEntryId,
        TMsvSelectionOrdering(KMsvNoGrouping, EMsvSortByNone, ETrue));
    iMtmStore=CMtmStore::NewL(*iSession);

    iUiRegistry=CMtmUiDataRegistry::NewL(*iSession);

   
    iMceMainView->HandleMsgServerStartupL();
    
    CMceDeliveryReportView* view3 = CMceDeliveryReportView::NewL( *iSessionHolder );
    CleanupStack::PushL( view3 );
    AddViewL( view3 );      // transfer ownership to CAknAppUi
    CleanupStack::Pop( view3 );

    iMceDeliveryView = view3;

     
    CMceMessageListView* mceListView = CMceMessageListView::NewL(
        iSession,
        KMsvLocalServiceIndexEntryId,
        *iSessionHolder,
        *iBitmapResolver,
        *iMceMainView );
    CleanupStack::PushL( mceListView );
    AddViewL( mceListView );      // transfer ownership to CAknAppUi
    CleanupStack::Pop( mceListView );
    iMceListView = mceListView;




    
    iAudioMsgEnabled = FeatureManager::FeatureSupported( KFeatureIdAudioMessaging ); // CR : 401-1806
    iPostcardEnabled = FeatureManager::FeatureSupported( KFeatureIdMmsPostcard ) ; // CR : 401-1806

    HandleMTMChangeL();

/*    CMceMessageListView* mceListView = CMceMessageListView::NewL(
        iSession,
        KMsvLocalServiceIndexEntryId,
        *iSessionHolder,
        *iBitmapResolver,
        *iMceMainView );
    CleanupStack::PushL( mceListView );
    AddViewL(mceListView);      // transfer ownership to CAknAppUi
    CleanupStack::Pop(); // mceListView
    iMceListView = mceListView;*/
    iMceListView->HandleMsgServerStartupL();



    iMceMainView->ListContainer()->ListItems()->SetAlwaysOnline( iAlwaysOnline );

    if ( iAlwaysOnline )
        {
        TRequestStatus status;
        TInt registrationStatus( 0 );

        //check network status
        iConnectionMonitor.GetIntAttribute(
            EBearerIdGSM, 0, KNetworkRegistration,
            registrationStatus, status );

        User::WaitForRequest( status );

        if ( status.Int() == KErrNone )
            {
            iMceMainView->ListContainer()->ListItems()->SetRoaming( 
                registrationStatus == ENetworkRegistrationRoaming );
            }
        }

    iMceUiFlags.ClearMceFlag( EMceUiFlagsWantToExit );
    iMceUiFlags.SetMceFlag( EMceUiFlagsServerReady );

    ToPhoneMemoryQueryL( iMceUiFlags.MceFlag( EMceUiFlagsMainViewActivated ) );

    iCoeEnv->AddForegroundObserverL( *this ); // CR : 401-1806
    //populate MMS templates in inbox which are preloaded KMmsMessageDumpDirectory.
    //CR:422-271
    PopulateMMSTemplates();
    
    iServerStarted = ETrue ;
    MCELOGGER_LEAVEFN("HandleServerStartupL()");
    }

// ----------------------------------------------------
// CMceUi::Session
// ----------------------------------------------------
CMsvSession& CMceUi::Session()
    {
    return *iSession;
    }

// ----------------------------------------------------
// CMceUi::HandleCommandL
// ----------------------------------------------------
void CMceUi::HandleCommandL( TInt aCommand )
    {
    MCELOGGER_WRITE_FORMAT("HandleCommandL: aCommand: %d", aCommand);

    if ( iMceUiFlags.MceFlag( EMceUiFlagsMediaUnavailable ) 
        && aCommand != EEikCmdExit 
        && aCommand != EMceCmdExit 
        && aCommand != EAknSoftkeyBack)
        {
        MCELOGGER_WRITE("HandleCommandL: media unavailable, leave");
        User::Leave( KMsvIndexBackup );
        }

    switch (aCommand)
        {
        case EEikCmdExit:
            Exit();
            break;
        case EMceCmdExit:
            CloseConnectionsBeforeExitL();
            if ( iMceUiFlags.MceFlag( EMceUiFlagsWantToExit ) )
                {
                HideOrExit();
                }
            break;
        case EAknCmdHideInBackground:
            HideOrExit();
            break;
        case EMceCmdNewFolder:
            CreateNewFolderL( );
            break;
        case EMceCmdRenameFolder:
            RenameFolderL();
            break;
        case EMceCmdSettings:
            SettingsDialogL();
            break;
        case EMceCmdDelete:
            HandleDeleteL();
            break;
        case EMceCmdUndelete:
            HandleUndeleteL();
            break;
        case EMceCmdCopy:
            MoveOrCopyEntriesL( ETrue );
            break;
        case EMceCmdMove:
            MoveOrCopyEntriesL( EFalse );
            break;
        case EMceCmdFetchNew:
            FetchNewL();
            break;
        case EMceCmdFetchSelected:
            FetchSelectedL();
            break;
        case EMceCmdFetchAll:
            FetchAllL();
            break;
        case EAknSoftkeyBack:
            RemoveTabs();
            ActivateLocalViewL( KMceMainViewListViewId );
            break;
        case EMceCmdOutboxStart:
            SendNowL();
            break;
        case EMceCmdOutboxSuspend:
            CancelSendingL();
            break;
        case EMceCmdOutboxMoveToDrafts:
            {
            if ( iMceListView->SyncMlOutboxInbox( KMsvGlobalOutBoxIndexEntryId ) )
                {
                SyncMlMoveFromOutboxToDraftsL();
                }
            else
                {
                MoveFromOutboxToDraftsL();
                }
            }
            break;
        case EMceCmdCBSApplication:
            LaunchCBSApplicationL();
            break;
        case EMceCmdUSSDEditor:
            LaunchServiceCommandEditorL();
            break;

        case EAknCmdHelp:
            LaunchHelpL();
            break;

        case EAknCmdOpen:
        case EMceCmdConnect:
        case EMceCmdCloseConnection:
        case EAknCmdUnmark:
        case EAknCmdMark:
        case EAknMarkAll:
        case EAknUnmarkAll:
            // these should be handled by view
            break;

        case EMceCmdReply:
            ReplyL(aCommand);
            break;

        case EMceCmdMarkAsRead:
        case EMceCmdMarkAsReadMsg:
        case EMceCmdMarkAsReadMsgs:
        case EMceCmdMarkAsReadEmails:
            MarkAsReadL();
            break;

        case EMceCmdMarkAsUnread:
        case EMceCmdMarkAsUnreadMsg:
        case EMceCmdMarkAsUnreadMsgs:
        case EMceCmdMarkAsUnreadEmails:
            MarkAsReadL( EFalse );
            break;

        case EMceCmdMailboxSettings:
            OpenMailboxSettingsL();
            break;

        case EMceCmdForward:
            ForwardL(aCommand);
            break;

        case EMceCmdZoomValueAutomatic:
        case EMceCmdZoomValueSmall:
        case EMceCmdZoomValueMedium:
        case EMceCmdZoomValueLarge:
            HandleZoomLevelChangeL( aCommand );
            break;
        case EMceCmdLanuchUniEditor:
            LaunchUniEditorL();
            break;
            
        case EMceCmdLaunchEmailEditor:
            CreateNewMessageL( GetToBeCreatedEmailType () );
            break;

        default:
        if ( aCommand >= EMceCmdFirstMTMFunction && aCommand < EMceCmdFirstMTMContextFunction )
            {
            const TMsgFunctionInfo* info=&iMTMFunctionsArray->At(aCommand-EMceCmdFirstMTMFunction);
            HandleMTMFunctionL(*info);
            }
        else if ( aCommand > EMceCmdCreateNewCommands && aCommand < EMceCmdFirstMTMFunction  )
                {
                const TInt messageIndex =
                    aCommand - EMceCmdCreateNewCommands - 1;
                __ASSERT_ALWAYS( messageIndex < iMsgTypesWriteSubmenu.Count(),
                    Panic( EMceUiErrCreateNewMessageCommand ) );
                CreateNewMessageL( iMsgTypesWriteSubmenu[messageIndex].iUid.iUid );
                }
        break;
        } // switch
    MCELOGGER_LEAVEFN("HandleCommandL()");
    }

// ----------------------------------------------------
// CMceUi::DynInitMenuPaneL
// ----------------------------------------------------
void CMceUi::DynInitMenuPaneL( TInt aResourceId, CEikMenuPane* aMenuPane )
    {
    ForceMtmLoaderFinish();
    TBool cbs = EFalse;
    if ( FeatureManager::FeatureSupported( KFeatureIdCellBroadcast ) )
        {
        cbs = ETrue;
        if ( iCsp )
            {
            cbs = CheckCspBitL();
            }
        }
    switch ( aResourceId )
        {
        case R_MCE_MAIN_VIEW_MENU:
            {
            // Run time Cell Broadcast variant.
            // Enable/disable CBS
            aMenuPane->SetItemDimmed( EMceCmdCBSApplication, !cbs );
            // Run time USSD variant.
            aMenuPane->SetItemDimmed( EMceCmdUSSDEditor,
                !FeatureManager::FeatureSupported( KFeatureIdUSSD ));

            aMenuPane->SetItemDimmed( EAknCmdHelp,
                !FeatureManager::FeatureSupported( KFeatureIdHelp ) );

            if ( iMsgTypesWriteSubmenu.Count() == 0 )
                {
                aMenuPane->SetItemDimmed( EMceCmdNewMessage, ETrue );
                }
            if ( MceViewActive( EMceMainViewActive ) )
                {
                AddMTMFunctionsL(*aMenuPane, EMceCmdCloseConnection);

                const CMceMainViewListContainer* listContainer =
                    iMceMainView->ListContainer();
                const TMceListItem listItem =
                    listContainer->CurrentItemListItem();
                if ( listItem.iExtraItem )
                    {
                    aMenuPane->SetItemDimmed( EMceCmdConnect, ETrue );
                    }
                else
                    {
                    const TUid  connectCapability =
                        { KUidMsvMtmUiQueryConnectionOrientedServices };
                    TInt rid;

                    iEntry->SetEntryL( listItem.iMsvId );
                    TUid uid = iEntry->Entry().iMtm;
                    CBaseMtmUiData* uiData = NULL;
                    if ( uid != KUidMsvLocalServiceMtm )
                        {
                        uiData=GetMtmUiDataL( uid );
                        }
                    if ( uiData && ( uid != KSenduiMtmSyncMLEmailUid ) 
                        && uiData->QueryCapability( connectCapability, rid )
                        == KErrNone )
                        {
                        // need to check if connected or not
                        if ( iEntry->Entry().Connected() )
                            {
                            aMenuPane->SetItemDimmed( EMceCmdConnect, ETrue );
                            }
                        }
                    else
                        {
                        aMenuPane->SetItemDimmed( EMceCmdConnect, ETrue );
                        }
                    }
                // if we have at least one connection open then do not delete EMceCmdCloseConnection
                CMsvEntrySelection* connectedAccounts = ConnectedServicesLC();
                if ( connectedAccounts->Count() == 0)
                    {
                    aMenuPane->SetItemDimmed( EMceCmdCloseConnection, ETrue );
                    }
                CleanupStack::PopAndDestroy( connectedAccounts );

                } // if ( MceViewActive( EMceMainViewActive ) )
            break;
            }
        case R_MCE_NEW_MESSAGE_MENU:
            {
            CEikMenuPaneItem::SData item;
            item.iCommandId = EMceCmdCreateNewCommands;
            item.iFlags = 0;
            item.iCascadeId = 0;
            const TInt count = iMsgTypesWriteSubmenu.Count();
            for(TInt loop = 0; loop < count; loop++)
                {
                item.iText = iMsgTypesWriteSubmenu[loop].iName;
                item.iCommandId++;
                aMenuPane->AddMenuItemL(item);
                }
            break;
            }
       case R_MCE_FOLDER_MENU:
            {
            aMenuPane->SetItemDimmed( EAknCmdHelp,
                !FeatureManager::FeatureSupported( KFeatureIdHelp ) );

            AddMTMFunctionsL(*aMenuPane, EAknCmdOpen);
            }
            break;
       case R_MCE_LOCAL_ZOOM_VALUE:
            {
            HandleZoomSubMenu( aMenuPane );
            }
            break;
        default:
            break;
        }// end switch
    }

// ----------------------------------------------------
// CMceUi::SendViaL
// ----------------------------------------------------
void CMceUi::SendViaL( TMsvId aId, TUid aMtm )
    {
    __ASSERT_DEBUG( aMtm == KSenduiMtmIrUid || aMtm == KSenduiMtmBtUid,
    Panic(EMceUiErrCanSendViaOnlyBtOrIr) );

    LeaveIfDiskSpaceUnderCriticalLevelL();

    // Get the file name
    TFileName fileName;
    TInt fileSize;
    RFile fileHandle;
    MceUtils::GetIrFilePathL( *iSession, aId, fileName, fileHandle, fileSize );
    CleanupClosePushL( fileHandle );

    // Required capabilities for message types
    TSendingCapabilities capabilities(
        0,
        0,
        TSendingCapabilities::ESupportsAttachments );

    // Create the message
    CMessageData* messageData = CMessageData::NewL();
    CleanupStack::PushL( messageData );
    messageData->AppendAttachmentHandleL( fileHandle );

    // Send the message with SendUI
    CSendUi* sendui = CSendUi::NewLC();
    sendui->CreateAndSendMessageL( aMtm, messageData, KNullUid, ETrue );

    CleanupStack::PopAndDestroy( 3 ); // sendui, messageData, fileHandle 
    }

// ----------------------------------------------------
// CMceUi::HandleKeyEventL
// ----------------------------------------------------
TKeyResponse CMceUi::HandleKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
    {
    if ( iEditorOperation )
        {
        MCELOGGER_WRITE_FORMAT("HandleKeyEventL: iEditorOperation set 0x%x so don't do anything", iEditorOperation );
        return EKeyWasConsumed;
        }

    if ( iMceUiFlags.MceFlag( EMceUiFlagsTabsActive ) && aType == EEventKey )
        {
        CAknTabGroup* tabGroup = NULL;
        if ( iDecoratedTabGroup )
            {
            tabGroup = ( CAknTabGroup* ) iDecoratedTabGroup->DecoratedControl();
            }

        if ( !tabGroup )
            {
            return EKeyWasNotConsumed;
            }

        return tabGroup->OfferKeyEventL( aKeyEvent, aType );
        }

    return EKeyWasNotConsumed;
    }

// ----------------------------------------------------
// CMceUi::LogEngine
// ----------------------------------------------------
CMceLogEngine* CMceUi::LogEngine()
    {
    return iMceLogEngine;
    }

// ----------------------------------------------------
// CMceUi::LaunchHelpL
// ----------------------------------------------------
void CMceUi::LaunchHelpL()
    {
    // activate Help application
    CArrayFix<TCoeHelpContext>* helpContext = AppHelpContextL();
    HlpLauncher::LaunchHelpApplicationL( iEikonEnv->WsSession(), helpContext );
    }

// ----------------------------------------------------
// CMceUi::HandleOpenNextPreviousL
// ----------------------------------------------------
void CMceUi::HandleOpenNextPreviousL( TBool aOpenNext )
    {
    MCELOGGER_ENTERFN("HandleOpenNextPreviousL()");
    __ASSERT_DEBUG( iMessageIterator, Panic(EMceUiMessageIteratorNotCreated));

    if ( iMessageIterator )
        {
        TInt error = (aOpenNext ?
            iMessageIterator->SetNextMessage() : iMessageIterator->SetPreviousMessage() );
        if ( error == KErrNone )
            {
            TBool local = iMceListView->ListContainer()->FolderEntry().iServiceId == KMsvLocalServiceIndexEntryId;
            if ( local && !iLocalScreenClearer ) 
                {
                iLocalScreenClearer = CAknLocalScreenClearer::NewL( ETrue );
                }

    // TODO
            CMceMessageListContainerBase* container = iMceListView->ListContainer();
            TMsvId currentItemId = iMessageIterator->CurrentMessage().Id();
            if ( container )
                {
                container->SetCurrentItemIdL( currentItemId );
                container->DrawNow();
/*                
                TInt currentItemIndex = container->ItemIndex( currentItemId );
                if ( currentItemIndex != KErrNotFound )
                    {
                    container->ListBox()->SetCurrentItemIndex( currentItemIndex );
                    container->ListBox()->DrawDeferred();
                    }*/
                }

            TMsvEntry currentEntry;
            TMsvId serviceId; // not used here but needed by GetEntry function
            if ( iSession->GetEntry( currentItemId, serviceId, currentEntry ) == KErrNone &&
                 currentEntry.iType == KUidMsvMessageEntry )
                {
                TRAPD( err, EditMTMEntryL( currentEntry ) );
                if ( err )
                    {
                    if ( iLocalScreenClearer )
                        {
                        delete iLocalScreenClearer;
                        iLocalScreenClearer = NULL;
                        }
                    User::Leave( err );
                    }
                }
            } // end if ( container )
        } // end if ( error == KErrNone )
    MCELOGGER_LEAVEFN("HandleOpenNextPreviousL()");
    }

// ----------------------------------------------------
// CMceUi::LaunchCBSApplicationL
// ----------------------------------------------------
void CMceUi::LaunchCBSApplicationL()
    {
    TVwsViewId id;
    id.iAppUid = KMceCBSApplication;
    id.iViewUid.iUid = KMceCBSApplicationStartView;
    ActivateViewL( id  );
    }

// ----------------------------------------------------
// CMceUi::LaunchServiceCommandEditorL
// ----------------------------------------------------
void CMceUi::LaunchServiceCommandEditorL() const
    {
    CPhCltUssd* ussdClient = CPhCltUssd::NewL( EFalse );
    CleanupStack::PushL( ussdClient );
    ussdClient->StartUssdEditor();
    CleanupStack::PopAndDestroy( ussdClient );
    }

// ----------------------------------------------------
// CMceUi::HandleResourceChangeL
// ----------------------------------------------------
void CMceUi::HandleResourceChangeL( TInt aType )
    {
    if ( !iServerStarted )
        {
    	return ;
        }
        
    CAknViewAppUi::HandleResourceChangeL( aType );
    if( aType == KEikDynamicLayoutVariantSwitch )
        {
        if ( iLocalScreenClearer )
	          {
	          delete iLocalScreenClearer;
	          iLocalScreenClearer = NULL;	
	          iLocalScreenClearer = CAknLocalScreenClearer::NewL( ETrue );
	          }

        if ( MceViewActive( EMceDeliveryReportsViewActive ) )
            {
            iMceDeliveryView->HandleClientRectChange();
            }
        iMceMainView->HandleClientRectChange();
        
        CMceNaviPaneFolderIndicator* findicator =
            static_cast<CMceNaviPaneFolderIndicator*>( iFolderIndicator->DecoratedControl() );
        findicator->HandleResourceChange( aType );
        }

    if( aType == KAknsMessageSkinChange )
        {
        const TInt count = iUiRegistry->NumRegisteredMtmDlls();
        for ( TInt i = 0; i < count; i++ )
            {
            iMtmStore->ReleaseMtmUiData( iUiRegistry->MtmTypeUid(i) );
            }

        iBitmapResolver->ChangeBitmapInIconArrayL();
        if ( !MceViewActive( EMceMainViewActive ) && iMceMainView )
            {
            //update the list icons, when delivery reports view is open and skin changes
            iMceMainView->ListContainer()->HandleResourceChange( aType );
            }
        if ( !MceViewActive(EMceMessageViewActive) && iMceListView 
            && iMceListView->ListContainer() )
            {
            iMceListView->ListContainer()->HandleResourceChange( aType );
            }

        LoadContextIconL();
        TitlePaneL()->DrawDeferred();

        CMceNaviPaneFolderIndicator* findicator =
            static_cast<CMceNaviPaneFolderIndicator*>( iFolderIndicator->DecoratedControl() );
        findicator->HandleResourceChange( aType );

        CAknContextPane* contextPane = (CAknContextPane *)(iEikonEnv->AppUiFactory(*this))
            ->StatusPane()->ControlL(TUid::Uid(EEikStatusPaneUidContext));
        contextPane->DrawDeferred();
        }
    if (iDecoratedTabGroup)
        {
        CAknTabGroup* tab = static_cast<CAknTabGroup*>( iDecoratedTabGroup->DecoratedControl() );
        if ( tab )
            {
            // Inform (possibly off-screen) tab group about the change
            tab->HandleResourceChange( aType );
            }
        }

    iResourceChangeCalled = ETrue;
    }

// ----------------------------------------------------
// CMceUi::CloseEditorApp
// ----------------------------------------------------
void CMceUi::CloseEditorApp()
    {
    if ( iEditorOperation )
        {
        TBool foundItem = EFalse;
        TMsvOp opId = iEditorOperation->Operation().Id();

        for (TInt cc=iOperations.Count()-1; cc>=0 && !foundItem; cc--)
            {
            if (iOperations[cc]->Operation().Id()==opId)
                {
                delete iOperations[cc];
                iOperations.Delete(cc);
                foundItem = ETrue;
                }
            }
        iEditorOperation = NULL;

        delete iLocalScreenClearer;
        iLocalScreenClearer = NULL;
        }
    }

// ----------------------------------------------------
// CMceUi::LoadContextIconL
// ----------------------------------------------------
void CMceUi::LoadContextIconL( )
    {
    CEikStatusPane *sp = ( (CAknAppUi*)iEikonEnv->EikAppUi() )->StatusPane();
    CAknContextPane* contextPane = (CAknContextPane *)sp->ControlL( 
        TUid::Uid(EEikStatusPaneUidContext) );

    RFs& fs=iEikonEnv->FsSession();

    MAknsSkinInstance* skins = AknsUtils::SkinInstance();
    CFbsBitmap* bitmap;
    CFbsBitmap* bitmapMask;

#ifdef RD_MULTIPLE_DRIVE
    TInt phoneDrive;
    // At this point, try avoid using any predefined numbers E.G. EDriveC
    // in order to increase the safety and code flexibility
    User::LeaveIfError( DriveInfo::GetDefaultDrive( DriveInfo:: EDefaultPhoneMemory, phoneDrive ) );
    if ( TInt( iSession->CurrentDriveL() ) != phoneDrive )
#else
    if ( TInt( iSession->CurrentDriveL()) == EDriveE )
#endif //RD_MULTIPLE_DRIVE
        {
#ifndef __SCALABLE_ICONS
        AknsUtils::CreateIconL( skins, KAknsIIDQgnMenuMceMmcCxt, bitmap,
           bitmapMask, iFilename, EMbmMuiuQgn_menu_mce_mmc_cxt,
           EMbmMuiuQgn_menu_mce_mmc_cxt + 1 );
#else
        AknsUtils::CreateIconL( skins, KAknsIIDQgnMenuMceMmcCxt, bitmap,
           bitmapMask, iFilename, EMbmMuiuQgn_menu_mce_mmc,
           EMbmMuiuQgn_menu_mce_mmc + 1 );
#endif
        }
    else
        {
#ifndef __SCALABLE_ICONS
        AknsUtils::CreateIconL( skins, KAknsIIDQgnMenuMceCxt, bitmap,
           bitmapMask, iFilename, EMbmMuiuQgn_menu_mce_cxt,
           EMbmMuiuQgn_menu_mce_cxt + 1 );
#else
        AknsUtils::CreateAppIconLC( skins, KMceApplicationUid, 
            EAknsAppIconTypeContext, bitmap, bitmapMask );
        CleanupStack::Pop( 2 ); // Both bitmaps are left in the cleanup stack
#endif
        }
    contextPane->SetPicture( bitmap, bitmapMask );
    }

// ----------------------------------------------------
// CMceUi::ResourceChangeCalled
// ----------------------------------------------------
TBool CMceUi::ResourceChangeCalled()
    {
    return iResourceChangeCalled;
    }

// ----------------------------------------------------
// CMceUi::ResetResourceChange
// ----------------------------------------------------
void CMceUi::ResetResourceChange()
    {
    iResourceChangeCalled = EFalse;
    }

// ----------------------------------------------------
// CMceUi::CheckTechnologyTypeFromMtm
// ----------------------------------------------------
TBool CMceUi::CheckTechnologyTypeFromMtm( const TUid aTechnologyType, TUid aMtmType )
    {
    TBool isMailMtm = EFalse;
    if ( aMtmType.iUid != 0 && aMtmType != KUidMsvLocalServiceMtm &&
         iUiRegistry->IsPresent( aMtmType ) )
    {
    // get MTM technology type
    TUid technologyType = iUiRegistry->TechnologyTypeUid( aMtmType );
        isMailMtm = ( aTechnologyType == technologyType );
        }
    return isMailMtm;
    }





// ----------------------------------------------------
// CMceUi::HandleMTMChangeL
// ----------------------------------------------------
void CMceUi::HandleMTMChangeL()
    {
    MCELOGGER_ENTERFN("HandleMTMChangeL()");
    if( !iMtmLoader )
        {
        iMtmLoader = new(ELeave) CMceIdleMtmLoader(
            *iMtmStore,
            iMsgTypesWritePopup,
            iMsgTypesWriteSubmenu,
            iMsgTypesSettings,
            *iMTMFunctionsArray,
            *iUiRegistry );
        }
    else
        {
        iMtmLoader->Cancel();
        }

    iMtmLoader->StartL(*iSession, iAudioMsgEnabled, iPostcardEnabled); // CR : 401-1806
    MCELOGGER_LEAVEFN("HandleMTMChangeL()");
    }

// ----------------------------------------------------
// CMceUi::GetMtmUiDataL
// will return NULL if no uiData found for entryType
// ----------------------------------------------------
CBaseMtmUiData* CMceUi::GetMtmUiDataL(TUid aMtm)
    {
    MCELOGGER_ENTERFN("GetMtmUiDataL()");
    MCELOGGER_WRITE_FORMAT("GetMtmUiDataL: mtm = 0x%x", aMtm.iUid );

    CBaseMtmUiData* uiData=NULL;
    if (iMtmStore)
        {
        TRAPD(error, ( uiData=&(iMtmStore->MtmUiDataL(aMtm)) ) );
        MCELOGGER_WRITE_FORMAT("GetMtmUiDataL: error = %d", error );
        if ( iMceUiFlags.MceFlag( EMceUiFlagsServerReady )  && error != KErrNotFound )
            {
            // KErrNotFound cover case where MTM is not installed but messages exist
            User::LeaveIfError( error );
            }
        }
    MCELOGGER_LEAVEFN("GetMtmUiDataL()");
    return uiData;
    }

// ----------------------------------------------------
// CMceUi::CanCreateNewAccountL
// ----------------------------------------------------
TBool CMceUi::CanCreateNewAccountL(TUid aMtm)
    {
    TBool canCreateNewAccount = EFalse;
    TMsvEntry serviceEntry;
    serviceEntry.iType=KUidMsvServiceEntry;
    serviceEntry.iMtm=aMtm;

    TInt rid;
    CBaseMtmUiData* uiData=GetMtmUiDataL(aMtm);
    if ( uiData && uiData->CanCreateEntryL( iRootEntry->Entry(), serviceEntry, rid ) )
        {
        canCreateNewAccount = ETrue;
        }
    return canCreateNewAccount;
    }

// ----------------------------------------------------
// CMceUi::DeleteAccountL
// ----------------------------------------------------
void CMceUi::DeleteAccountL(TMsvId aId)
    {
    TMsvEntry   entry;
    GetEntryL( aId, entry );
    const TUid mtm = entry.iMtm;
    CBaseMtmUi* ui = &iMtmStore->ClaimMtmUiL( mtm );
    if (ui)
        {
        CMtmStoreMtmReleaser::CleanupReleaseMtmUiLC(*iMtmStore, mtm);
        }

    CMsvOperation* op = NULL;
    __ASSERT_DEBUG( !iDeleteOperation,
        Panic( EMceUiErrAlreadyDeletingAccount ) );

// Free disk space request for delete to be added

    CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
    CleanupStack::PushL( singleOpWatcher );

    if (ui)
        {
        ui->BaseMtm().SetCurrentEntryL(iSession->GetEntryL(KMsvRootIndexEntryId));
        CAknInputBlock::NewLC();
        op=ui->DeleteServiceL(entry, singleOpWatcher->iStatus);
        CleanupStack::PopAndDestroy(); // CAknInputBlock
        CleanupStack::PushL(op);
        }
    else
        {
        // could not load mtm, so delete as normal local entry
        iEntry->SetEntryL( KMsvRootIndexEntryId );

        CMsvProgressReporterOperation* progOp =
            CMsvProgressReporterOperation::NewL(
            *iSession, singleOpWatcher->iStatus, EMbmAvkonQgn_note_erased);
        CleanupStack::PushL( progOp );

        CMsvEntrySelection* selection = new( ELeave ) CMsvEntrySelection();
        CleanupStack::PushL( selection );
        selection->AppendL( entry.Id() );
        CMsvOperation* subOp = iEntry->DeleteL( *selection, progOp->RequestStatus());
        CleanupStack::PopAndDestroy( selection );
        progOp->SetOperationL( subOp ); // this takes ownership immediately, so no cleanupstack needed.
        op = progOp;
        }

    iOperations.AppendL( singleOpWatcher );
    CleanupStack::Pop( 2 ); // singleOpWatcher, op
    singleOpWatcher->SetOperation( op );
    iDeleteOperation = singleOpWatcher;
    iMailboxDeleteOperation = op->Id();
    MCELOGGER_WRITE_FORMAT("free disk requested, iDeleteOperation set 0x%x", iDeleteOperation );
    MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );

// Cancel the free disk space request to be added

    if ( ui )
        {
        CleanupStack::PopAndDestroy();// release mtmUi
        }

    }

// ----------------------------------------------------
// CMceUi::SettingsDialogL
// ----------------------------------------------------
void CMceUi::SettingsDialogL()
    {
    CMceUidNameArray* tempArray = CMceUidNameArray::NewL();

    if (( iSelectableEmail )&& (!iEmailFramework))
        {
        CleanupStack::PushL( tempArray );
        const TInt count = iMsgTypesSettings.Count();

        // get all email accounts (visible)
        CArrayFix<TUid>* listItemUids =
            new ( ELeave ) CArrayFixFlat<TUid>( KMceArrayGranularity );
        CleanupStack::PushL(listItemUids);
        CMsvEntry* entry = iSession->GetEntryL( KMsvRootIndexEntryId );
        CleanupStack::PushL( entry );

        TInt canCreateNew;   

        TInt cnt = entry->Count();
        if ( cnt != 0 )
            {
            entry->SetSortTypeL( TMsvSelectionOrdering(
                KMsvGroupByType | KMsvGroupByStandardFolders, EMsvSortByDetailsReverse, ETrue ) );

            // Add default item first
            for ( TInt cc = entry->Count(); --cc >= 0; )
                {
                TMsvEntry tentry = (*entry)[cc];                

                if ( tentry.iType.iUid == KUidMsvServiceEntryValue &&
                     tentry.Id() != KMsvLocalServiceIndexEntryIdValue )
                    {
                    const TBool noRelatedId = tentry.iRelatedId == KMsvNullIndexEntryId || tentry.iRelatedId == tentry.Id();

                    TBool appendEmail = EFalse;

                    if( tentry.Visible() )
                        {
                        appendEmail = ETrue;
                        }
                    else
                        {
                        CMtmUiDataRegistry* uiRegistry = CMtmUiDataRegistry::NewL( *iSession );                
                        CleanupStack::PushL(uiRegistry);
                        if ( uiRegistry->IsPresent( tentry.iMtm ) &&
                             uiRegistry->IsPresent( KUidMsgTypePOP3 ) )
                            {            
                            TUid mailMTMTechType = uiRegistry->TechnologyTypeUid( KUidMsgTypePOP3 );                                          
                            if( uiRegistry->TechnologyTypeUid( tentry.iMtm ) ==
                                mailMTMTechType )
                                {
                                appendEmail = ETrue;                    
                                }
                            }
                            CleanupStack::PopAndDestroy( uiRegistry );
                        } 

                    if ( appendEmail )
                        {                         
                        TBool append = ETrue; 
                        // query capability (new message)
                        TUid entryUid;

                        if ( tentry.iMtm == KSenduiMtmPop3Uid ||
                             tentry.iMtm == KSenduiMtmImap4Uid)
                            {                        
                            entryUid = KSenduiMtmSmtpUid;
                            }
                        else
                            {
                            entryUid = tentry.iMtm;     
                            }

                        CBaseMtmUiData* mtmUiData;

                        TRAPD( returnVal, mtmUiData =
                               &( iMtmStore->MtmUiDataL( entryUid ) ) );

                        if ( returnVal == KErrNone)
                            {
                            TInt ret = mtmUiData->QueryCapability( KUidMtmQueryCanSendMsg, canCreateNew );                                   

                            if ( ret == KErrNone ) 
                                {
                                append = ETrue;
                                }
                            else
                                {
                                append = EFalse;    
                                }                
                            }
                        else
                            {
                            append = EFalse;                                
                            }                            

                        iMtmStore->ReleaseMtmUiData( entryUid );                  

                        if( append )
                            {                     
                            listItemUids->AppendL( entryUid );
                            }
                        }
                    }
                }
            }
        TBool emailIncluded = EFalse;        
        TBool syncMLIncluded = EFalse;        
        TUid uidMsgValTypeEmailMtmVal = GetFsIntegratedEmailAppMtmPluginId(); 
        CDesCArrayFlat* items = new(ELeave)CDesCArrayFlat( KMceArrayGranularity );
        CleanupStack::PushL( items );
        for ( TInt loop = 0; loop < count ; loop++)
            {
            if ( FindMtmInVisibleListL( iMsgTypesSettings[loop].iUid, *listItemUids ) )
                {
                if ( !emailIncluded &&
                    ( iMsgTypesSettings[loop].iUid == KSenduiMtmSmtpUid ) ) 
                    {
                    tempArray->AppendL( iMsgTypesSettings[loop] );
                    emailIncluded = ETrue;
                    }                
                // Following is added because SyncML was missing from the list
                else if ( !syncMLIncluded &&
                          ( iMsgTypesSettings[loop].iUid == KSenduiMtmSyncMLEmailUid ) )
                    {
                    tempArray->AppendL( iMsgTypesSettings[loop] );
                    syncMLIncluded = ETrue;					
                    }
	        else if(iMsgTypesSettings[loop].iUid!=uidMsgValTypeEmailMtmVal)
                    {
                    tempArray->AppendL( iMsgTypesSettings[loop] );
                    }
                }
            else
                {
                tempArray->AppendL( iMsgTypesSettings[loop] );    
                }        
            }
            CleanupStack::PopAndDestroy( items ); 
            CleanupStack::PopAndDestroy( entry );
            CleanupStack::PopAndDestroy( listItemUids );
        }
    else if(iEmailFramework)  //Freestyle Feature is disabled and CMail Feature is enabled 
        {
        MCELOGGER_WRITE("CMceUi::SettingsDialogL: cmail ");
        CleanupStack::PushL( tempArray );
        const TInt count = iMsgTypesSettings.Count();
        for (TInt loop=0; loop < count; loop++)
            {
            if ( (iMsgTypesSettings[loop].iUid == KSenduiMtmSmtpUid ) ||
                    ( iMsgTypesSettings[loop].iUid == KSenduiMtmSyncMLEmailUid )||
                    (iMsgTypesSettings[loop].iUid == KUidMsgTypeFsMtmVal))
                {
                MCELOGGER_WRITE_FORMAT("not Loading %x", iMsgTypesSettings[loop].iUid );
                continue;
                }
            else
                {
                MCELOGGER_WRITE_FORMAT(" Loading %x", iMsgTypesSettings[loop].iUid);
                tempArray->AppendL( iMsgTypesSettings[loop] );
                }
            }
        }
    
    else    //Freestyle Feature is disabled and CMail Feature is disabled 
            
       {

    CleanupStack::PushL( tempArray );
    const TInt count = iMsgTypesSettings.Count();
    for (TInt loop=0; loop < count; loop++)
        {
        tempArray->AppendL( iMsgTypesSettings[loop] );
        }
		}

    TUid uid;
    uid.iUid = KMceAnswerToLifeUniverseAndEverything;
    // this is not used anywhere, two last items in the list are
    // ALWAYS cbs settings and mce general settings

    // Run time Cell Broadcast variant.
    TBool cbs = EFalse;
    if ( FeatureManager::FeatureSupported( KFeatureIdCellBroadcast ) )
        {
        cbs = ETrue;
        if ( iCsp )
            {
            cbs = CheckCspBitL();
            }
        }
    if ( cbs )
        {
        HBufC* text = StringLoader::LoadL( R_MCE_CBS_SETTINGS_TEXT, iEikonEnv );
        TUidNameInfo cbsSettings( uid, *text );
        delete text;
        tempArray->AppendL( cbsSettings );
        }

    HBufC* text = StringLoader::LoadL( R_MCE_GENERAL_SETTINGS_TEXT, iEikonEnv );
    TUidNameInfo generalSettings( uid, *text );
    delete text;
    tempArray->AppendL( generalSettings );

    // This is changed to automatic because local zoom should change only listbox zoom value
    // so settings dialog zoom value should come from general settings and so we need to change
    // local zoom to automatic before launching settings dialog
    // Is settings opened from General Settings
    CMuiuLock* repositoryLock = CMuiuLock::NewL( KMuiuLockSettings );
    CleanupStack::PushL(repositoryLock);
    TInt err = repositoryLock->Reserve();

    // Check that settings are not opened from General Settings
    if ( !err )
        {
        TAknUiZoom previous = ZoomLevelChangedL( EAknUiZoomAutomatic );
        iMceUiFlags.SetMceFlag( EMceUiFlagsSettingsDialogOpen );
        CMceSettingsDialog* dlg = CMceSettingsDialog::NewL( *tempArray, this, iSession);
        dlg->ExecuteLD();
        iMceUiFlags.ClearMceFlag( EMceUiFlagsSettingsDialogOpen );
        ZoomLevelChangedL( previous );
        }
    else
        {
        // Show information note: General Settings has opened settings
        CAknNoteDialog* dlg = new (ELeave) CAknNoteDialog(
            CAknNoteDialog::ENoTone, CAknNoteDialog::ELongTimeout);
        dlg->ExecuteLD(R_MCE_NOTE_SETTINGS_OPEN_GS);

        }
    // Release repository
    repositoryLock->Release();
    CleanupStack::PopAndDestroy( 2 ); // tempArray, repositoryLock

    }

// ----------------------------------------------------
// CMceUi::CreateNewMessageL
// Create a new message of the given type, in the given location
// ----------------------------------------------------
void CMceUi::CreateNewMessageL(TInt aMessageType)
    {
    __ASSERT_DEBUG( aMessageType != KUidMsvLocalServiceMtmValue,
        Panic( EMceUiErrLocalMtm ) );
    LeaveIfDiskSpaceUnderCriticalLevelL();
    TUid messageTypeOrig;
    messageTypeOrig.iUid = aMessageType;
    TUid msgTypeUid; 
    msgTypeUid.iUid = 0;

    TBool tabsToCleanupStack = EFalse;
    TMsvId service = KMsvNullIndexEntryId;
    if ( MceViewActive( EMceMessageViewActive ) && iMceListView )
        {
        const TMsvEntry& entry = iMceListView->ListContainer()->FolderEntry();
        //cmail change
        if ( (iSelectableEmail) && (!iEmailFramework ))
            {
            if ( entry.iMtm == KSenduiMtmImap4Uid ||
                entry.iMtm == KSenduiMtmPop3Uid )
            {
            service = entry.iServiceId;
            }
            }
        else
            {
	        if ( aMessageType == entry.iMtm.iUid ||
	            ( aMessageType == KSenduiMtmSmtpUidValue
	               && (entry.iMtm == KSenduiMtmImap4Uid
	               || entry.iMtm == KSenduiMtmPop3Uid ) ) )
            {
            service = entry.iServiceId;
            }
        }
        }


    if ( service == KMsvNullIndexEntryId )
        {
        //cmail change
        if ( (iSelectableEmail) && (!iEmailFramework ) )
            {
            if ( GetDefaultServiceL( aMessageType, service, msgTypeUid )
        	     == EFalse )        
                {
                return;
                }
            }
        else
            {
        GetDefaultServiceL( aMessageType, service );
        }
        }    

    if ( ((iSelectableEmail) && (!iEmailFramework ))&& ( messageTypeOrig == KSenduiMtmSmtpUid ) )
        {	
        if( ( msgTypeUid == KSenduiMtmSmtpUid) ||
            ( msgTypeUid.iUid == KMsvNullIndexEntryId ) )
            {
    msgTypeUid.iUid = aMessageType;
            }        
        }
    else
        {
        msgTypeUid.iUid = aMessageType;            
        } 

    if ( iMceUiFlags.MceFlag( EMceUiFlagsTabsActive ) )
        {
        // must remove tabs because if no mailboxes created then
        // mailbox settings dialog is displayed and tabs should not be shown then.
        RemoveTabs();
        CleanupStack::PushL( TCleanupItem( ShowTabs, this ) );
        tabsToCleanupStack = ETrue;
        }

    CreateAndEditNewEntryL(
        KUidMsvMessageEntryValue,
        msgTypeUid,
        KMsvDraftEntryId,
        service );

    if ( tabsToCleanupStack )
        {
        CleanupStack::PopAndDestroy(); // TCleanupItem - will show tabs again
        }

        // NCN reset does not requied for new email creation
    

    }

// ----------------------------------------------------
// CMceUi::ShowTabs
// Static function.
// Used in CreateNewMessageL as TCleanupItem.
// ----------------------------------------------------
void CMceUi::ShowTabs(TAny* aAny)
    {
    CMceUi* mceUi = (CMceUi*) aAny;
    if ( mceUi && mceUi->MceViewActive( EMceMessageViewActive ) && mceUi->iMceListView )
        {
        TRAP_IGNORE( mceUi->ShowTabsL( mceUi->iMceListView->ListContainer()->CurrentFolderId() ) );
        }
    }

// ----------------------------------------------------
// CMceUi::ResetEditorOperation
// Static function.
// Used in CreateNewMessageL as TCleanupItem.
// ----------------------------------------------------
void CMceUi::ResetEditorOperation(TAny* aAny)
    {
    CMceUi* mceUi = (CMceUi*) aAny;
    MCELOGGER_WRITE_FORMAT("ResetEditorOperation iEditorOperation 0x%x set NULL", mceUi->iEditorOperation );
    mceUi->iEditorOperation = NULL;
    }

// ----------------------------------------------------
// CMceUi::CreateAndEditNewEntryL
// ----------------------------------------------------
void CMceUi::CreateAndEditNewEntryL(TMsvId aParentId, TMsvEntry& aNewEntry)
    {
    MCELOGGER_ENTERFN("CreateAndEditNewEntryL()");

    LeaveIfDiskSpaceUnderCriticalLevelL();

    __ASSERT_DEBUG(aNewEntry.iMtm != KUidMsvLocalServiceMtm,
        Panic( EMceUiErrLocalMtm ) );

    aNewEntry.iDate.HomeTime();

    // --- Get the MTM UI relevant to the message type ---
    CBaseMtmUi& mtmUi = iMtmStore->GetMtmUiLC( aNewEntry.iMtm );
    CMsvEntry* centry = iSession->GetEntryL( aParentId );
    // this allocates memory so cleanupstack is needed
    CleanupStack::PushL( centry );
    CAknInputBlock::NewLC();

    CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL(*this);
    CleanupStack::PushL( singleOpWatcher );

    CleanupStack::PushL( TCleanupItem( ResetEditorOperation, this ) );

    mtmUi.SetPreferences( mtmUi.Preferences() | EMtmUiFlagEditorPreferEmbedded );
    
    CMsvOperation* op = mtmUi.CreateL(
        aNewEntry,
        *centry,
        singleOpWatcher->iStatus );

    MCELOGGER_WRITE_FORMAT("CreateAndEditNewEntryL: iEditorOperation set 0x%x", singleOpWatcher );
    iEditorOperation = singleOpWatcher;

    CleanupStack::PushL( op );
    MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
    iOperations.AppendL( singleOpWatcher );
    CleanupStack::Pop( op ); // singleOpWatcher, op
    CleanupStack::Pop(); // ResetEditorOperation everything ok, don't reset iEditorOperation
    CleanupStack::Pop( singleOpWatcher );

    singleOpWatcher->SetOperation( op );

    if ( aNewEntry.iType == KUidMsvMessageEntry &&
        iUiRegistry &&
        iUiRegistry->IsPresent( op->Mtm() ) )
        {
        iMtmStore->ClaimMtmUiL( op->Mtm() );            
        }

    CleanupStack::PopAndDestroy(3); // CAknInputBlock, centry, release MtmUi

    if ( MceViewActive( EMceMessageViewActive ) )
        {
        iMceListView->ListContainer()->ClearSelection();
        }

    MCELOGGER_LEAVEFN("CreateAndEditNewEntryL()");
    }

// ----------------------------------------------------
// CMceUi::CreateAndEditNewEntryL
// ----------------------------------------------------
void CMceUi::CreateAndEditNewEntryL(
    TInt aEntryType,
    TUid aMtm,
    TMsvId aParentId,
    TMsvId aServiceId )
    {
    __ASSERT_DEBUG(aMtm != KUidMsvLocalServiceMtm,
        Panic( EMceUiErrLocalMtm ) );
    TMsvEntry nentry;
    nentry.iMtm = aMtm;
    nentry.iType.iUid = aEntryType;
    nentry.iDate.HomeTime();
    nentry.iServiceId = aServiceId;
    CreateAndEditNewEntryL( aParentId, nentry );
    }

// ----------------------------------------------------
// CMceUi::GetDefaultServiceL
// when MceIntegration runtime flag is on
// ----------------------------------------------------
TBool CMceUi::GetDefaultServiceL( TInt aMtm, TMsvId& aService, TUid& aMtmUid )
    {
    TBool retVal = ETrue;
    TUid mtm = { aMtm };       

    aService = MsvUiServiceUtilities::DefaultServiceForMTML( *iSession,
                                                             mtm,
                                                             ETrue );

    if ( mtm == KSenduiMtmImap4Uid || mtm == KSenduiMtmPop3Uid
            || mtm == KSenduiMtmSmtpUid )
        {
        retVal = CMceSettingsEmailSel::ShowSelectEmailDlgL( aService,  aMtmUid );
        }

    return retVal;
    }

// ----------------------------------------------------
// CMceUi::GetDefaultServiceL
// ----------------------------------------------------
void CMceUi::GetDefaultServiceL(TInt aMtm, TMsvId& aService)
    {
    TUid mtm = { aMtm };

    aService = MsvUiServiceUtilitiesInternal::DefaultServiceForMTML(
        *iSession,
        mtm,
        ETrue );
    }

// ----------------------------------------------------
// CMceUi::OpCompleted
// ----------------------------------------------------
void CMceUi::OpCompleted(
    CMsvSingleOpWatcher& aOpWatcher,
    TInt aCompletionCode )
    {
    MCELOGGER_ENTERFN("OpCompleted()");
    CMsvOperation* op=&aOpWatcher.Operation();
    MCELOGGER_WRITE_FORMAT("operation id=%d completed", op->Id() );

    // Store the command ID
    TMsvOp tempOpID = op->Id();
    TUid tempOpMtm = op->Mtm();
    
    if ( &aOpWatcher == iEditorOperation )
        {
        MCELOGGER_WRITE_FORMAT("iEditorOperation 0x%x set NULL", iEditorOperation );
        iEditorOperation = NULL;
        if ( iMtmStore && //tempOpMtm != KUidMsvLocalServiceMtm && tempOpMtm != KUidMsvNullEntry &&
            iUiRegistry &&
            iUiRegistry->IsPresent( tempOpMtm ) )
            {
            iMtmStore->ReleaseMtmUi( tempOpMtm );                
            }
        }
    
#ifdef _DEBUG
    TRAPD(ignore, DoOperationCompletedL(op, aCompletionCode));
    MCELOGGER_WRITE_FORMAT("DoOperationCompletedL ignore %d", ignore );
#else
    TRAP_IGNORE(DoOperationCompletedL(op, aCompletionCode));
#endif

    ClearDontExitOnNextOperationComplete();
    
    TBool foundItem = EFalse;
    for (TInt cc = iOperations.Count()-1; cc >= 0 && !foundItem; cc--)
        {
        if (iOperations[cc]->Operation().Id()==op->Id())
            {
            delete iOperations[cc];
            iOperations.Delete(cc);
            foundItem = ETrue;
            }
        }

    if ( &aOpWatcher == iDeleteOperation )
        {
        MCELOGGER_WRITE_FORMAT("iDeleteOperation 0x%x set NULL", iDeleteOperation );
        iDeleteOperation = NULL;

        if ( iMMSNotifications && iMMSNotifications->Count() > 0 )
            {
            //delete MMS notifications
            TBuf8<1> params;
            params.Append( KMceMMSNotifOne8 );
            TRAPD( error, HandleMMSNotificationsDeleteL( params ) );
            if ( error )
                {
                if ( !iMceErrorUi )
                    {
                    TRAP_IGNORE( iMceErrorUi = CErrorUI::NewL(*iCoeEnv) );
                    }
                if ( iMceErrorUi )
                    {
                    TRAP_IGNORE( iMceErrorUi->ShowGlobalErrorNoteL( error ) );
                    }
                // ignore
                }
            }

// Cancel free disk space request to be added

        }

    else if ( iMMSNotifications
        && ( tempOpMtm == KUidMsgMMSNotification ) )
        {
        // check if MMS notification delete failed
        TRAP_IGNORE( CheckMMSNotifDelFailedL() );
        }
    else
        {
        //nothing special done
        }


    if ( &aOpWatcher == iFetchNewOperation )
        {        
        iFetchNewOperation = NULL;
    // TODO
        if ( ( iMceListView->ListContainer()->Count() )
            && MceViewActive( EMceMessageViewActive ) )
            {        
//            iMceListView->ListContainer()->ListBox()->SetCurrentItemIndex( 0 );
//            iMceListView->ListContainer()->ListBox()->DrawDeferred();
            }
        }

// Email messages cannot be copied or moved, show the note
    if ( ( iMoveOrCopyMailOperation != -1 ) && ( iMoveOrCopyMailOperation == tempOpID ) )
        {
        TRAP_IGNORE( InformationNoteCannotMoveCopyEMailL() );
        }

    if ( iHandleNewMsgToInbox )
        {
        TRAP_IGNORE( HandleNewMsgToInboxL( EFalse, NULL ) );
        }

    __ASSERT_DEBUG( foundItem, Panic( EMceUiErrOperationNotFound ) );
    MCELOGGER_LEAVEFN("OpCompleted()");
    }

// ----------------------------------------------------
// CMceUi::DoOperationCompletedL
// ----------------------------------------------------
void CMceUi::DoOperationCompletedL(
    CMsvOperation* aOperation,
    TInt aCompletionCode )
    {
    __ASSERT_DEBUG( aOperation, Panic( EMceUiErrOperationNull ) );
    if ( !aOperation )
        {
        return;
        }

    if ( iLocalScreenClearer && 
         aCompletionCode != CMsgEmbeddedEditorWatchingOperation::EMsgExitNext &&
         aCompletionCode != CMsgEmbeddedEditorWatchingOperation::EMsgExitPrevious )
        {
        
        delete iLocalScreenClearer;
        iLocalScreenClearer = NULL;
        
        }

    MCELOGGER_WRITE_FORMAT("CMceUi::DoOperationCompletedL: aCompletionCode: %d", aCompletionCode );
    
    if ( aOperation->Id() == iMailboxDeleteOperation )
        {
        CMceMainViewListItemArray* array = iMceMainView->ListContainer()->ListItems();
        if ( array )
            {
            array->HandleSessionEventL(EMsvEntriesDeleted, NULL, NULL, NULL );
            }
        }

    if ( ViewUpdateSuppressionFlag() && iBlockingOperation == aOperation )
        {
        SetViewUpdateSuppressionFlag( EFalse, NULL );
        iMceListView->UpdateViewL();
        }

    TInt closedEntryId = 0;
    // Retrieve value of KMuiuKeyCurrentMsg
    TInt r = RProperty::Get( KPSUidMuiu, KMuiuKeyCurrentMsg, closedEntryId );
    if ( r != KErrNone )
        {
        closedEntryId = 0;
        }
    if ( aCompletionCode == EEikCmdExit &&
        !iMceUiFlags.MceFlag( EMceUiFlagsDoNotExitAfterNextOperationComplete ) )
        {
        MCELOGGER_WRITE("CMceUi::DoOperationCompletedL: EXIT");
        iAvkonViewAppUi->ProcessCommandL( EAknCmdHideInBackground );
        return;
        }
    // viewer next/prev
    else if ( aCompletionCode == CMsgEmbeddedEditorWatchingOperation::EMsgExitNext ||
        aCompletionCode == CMsgEmbeddedEditorWatchingOperation::EMsgExitPrevious )
        {
        MCELOGGER_WRITE("CMceUi::DoOperationCompletedL: Opening next/previous");
        if ( iMessageIterator && closedEntryId > 0 )
            {
            TMsvEntry currentEntry;
            TMsvId serviceId; // not used here but needed by GetEntry function
            // Get current entry
            if ( iSession->GetEntry( closedEntryId, serviceId, currentEntry ) == KErrNone )
                {
                iMessageIterator->SetCurrentMessageL( currentEntry );
                }
            }
        HandleOpenNextPreviousL( aCompletionCode ==
            CMsgEmbeddedEditorWatchingOperation::EMsgExitNext );
        if ( !IsForeground() )
            {
             // bring mce application to foreground
            iEikonEnv->RootWin().SetOrdinalPosition(0);
            }
        return;
        }
    else
        {
        MCELOGGER_WRITE("CMceUi::DoOperationCompletedL: deleting iMessageIterator");
        // Viewer closed
        if ( closedEntryId > 0 && iMessageIterator )
            {
            CMceMessageListContainerBase* container = iMceListView->ListContainer();
            if ( container )
                {
                container->SetCurrentItemIdL( closedEntryId );
                }
            }
        delete iMessageIterator;
        iMessageIterator = NULL;
        }

    if ( !iMceErrorUi )
        {
        iMceErrorUi = CErrorUI::NewL(*iCoeEnv);
        }

    if ( aCompletionCode == KMsvIndexRestore )
        {
        iMceErrorUi->ShowGlobalErrorNoteL( aCompletionCode );
        }

    const TDesC8& progress = aOperation->ProgressL();

    if (aOperation->Mtm() != KUidMsvLocalServiceMtm )
        {
        MCELOGGER_WRITE_FORMAT("CMceUi::DoOperationCompletedL: calling mtm ui 0x%x DisplayProgressSummary", aOperation->Mtm().iUid );
        CAknInputBlock::NewLC();
        CMtmStore* mtmStore=CMtmStore::NewL(*iSession);
        CleanupStack::PushL( mtmStore );
        
        CBaseMtmUi& ui = mtmStore->GetMtmUiLC( aOperation->Mtm() );
        if ( aOperation->Service() > KFirstFreeEntryId
            && ( aOperation->Mtm() == KSenduiMtmImap4Uid
            || aOperation->Mtm() == KSenduiMtmPop3Uid ) )
            {
            ui.BaseMtm().SwitchCurrentEntryL( aOperation->Service() );
            }
        ui.DisplayProgressSummary( progress );
        CleanupStack::PopAndDestroy( 3 ); // CAknInputBlock, mtmStore, release mtmUi        
        MCELOGGER_WRITE("DisplayProgressSummary done");
        return;
        }

    if (progress.Length() == 0)
        {
        return;
        }

    TMsvLocalOperationProgress localprogress =
        McliUtils::GetLocalProgressL( *aOperation );

    if ( ( aCompletionCode == KErrNone
        || aCompletionCode == KErrCancel )
        && ( localprogress.iError == KErrNone
        || localprogress.iError == KErrCancel ) )
        {
        return;
        }

    MCELOGGER_WRITE_FORMAT("CMceUi::DoOperationCompletedL, localProgress.iType %d", localprogress.iType )
    MCELOGGER_WRITE_FORMAT("error %d", localprogress.iError?localprogress.iError:aCompletionCode )

    iMceErrorUi->ShowGlobalErrorNoteL( localprogress.iError?localprogress.iError:aCompletionCode );
    }

// ----------------------------------------------------
// CMceUi::CreateNewFolderL
// ----------------------------------------------------
void CMceUi::CreateNewFolderL()
    {
    LeaveIfDiskSpaceUnderCriticalLevelL();

    TMsvEntry newFolder;
    const TMsvId parentId=iMceListView->ListContainer()->CurrentFolderId();
    if ( parentId != KMceDocumentsEntryId )
        {
#if defined(_DEBUG)
        Panic( EMceUiErrCannotCreateFolder );
#endif
        return;
        }

    _LIT(KMceFormatFolderName, "%S(%02d)");
    TBuf<KMceMaxFolderLength> folderName;
    TInt num = 0;
    TBuf<KMceTextLength> defaultFolderName;
    StringLoader::Load( defaultFolderName, R_MCE_DEFAULT_FOLDER_NAME, iEikonEnv );
    folderName.Copy( defaultFolderName );
    while( iMceListView->IsFolderNameUsedL( folderName ) )
        {
        num++;
        folderName.Format( KMceFormatFolderName, &defaultFolderName, num );
        AknTextUtils::DisplayTextLanguageSpecificNumberConversion( folderName );
        }

    if ( FolderNameQueryL( R_MCE_CREATE_FOLDER, folderName ) )
        {
        CAknInputBlock::NewLC();
        CMsvSingleOpWatcher* singleOpWatcher=CMsvSingleOpWatcher::NewL( *this );
        CleanupStack::PushL( singleOpWatcher );

        iEntry->SetEntryL( parentId );
        newFolder.iDate.HomeTime();
        newFolder.iDetails.Set( folderName );
        newFolder.iType = KUidMsvFolderEntry;
        newFolder.iMtm = iEntry->Entry().iMtm;
        newFolder.iServiceId= iEntry->OwningService();

        CMsvOperation* op = iEntry->CreateL( newFolder, singleOpWatcher->iStatus );
        CleanupStack::PushL( op );
        iOperations.AppendL( singleOpWatcher );
        CleanupStack::Pop( 2 ); // singleOpWatcher, op
        singleOpWatcher->SetOperation( op );
        MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
        CleanupStack::PopAndDestroy(); //CAknInputBlock
        }
    }

// ----------------------------------------------------
// CMceUi::RenameFolderL
// ----------------------------------------------------
void CMceUi::RenameFolderL()
    {
    const CMceMessageListContainerBase* container = iMceListView->ListContainer();
    TMsvId currentId = container->CurrentItemId();

    CMsvEntry* centry=iSession->GetEntryL( currentId );
    CleanupStack::PushL( centry );
    TMsvEntry entry = centry->Entry();

    __ASSERT_DEBUG(entry.iType == KUidMsvFolderEntry,
        Panic(EMceUiErrRenameNotFolder));
    __ASSERT_DEBUG(entry.iMtm == KUidMsvLocalServiceMtm,
        Panic(EMceUiErrRenameNotLocal));


    TBuf<KMceMaxFolderLength> buf = entry.iDetails.Left( KMceMaxFolderLength );
    if ( FolderNameQueryL( R_MCE_CREATE_FOLDER, buf, entry.Id() ) )
        {
        CAknInputBlock::NewLC();
        CMsvSingleOpWatcher* singleOpWatcher=CMsvSingleOpWatcher::NewL( *this );
        CleanupStack::PushL(singleOpWatcher);
        iEntry->SetEntryL( entry.Id() );
        entry.iDetails.Set( buf );
        CMsvOperation* op = iEntry->ChangeL( entry, singleOpWatcher->iStatus );
        CleanupStack::PushL( op );
        iOperations.AppendL(singleOpWatcher);
        CleanupStack::Pop( 2 ); // singleOpWatcher, op
        singleOpWatcher->SetOperation(op);
        MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
        CleanupStack::PopAndDestroy(); //CAknInputBlock
        }
    CleanupStack::PopAndDestroy( centry );
    }

// ----------------------------------------------------
// CMceUi::FolderNameQueryL
// ----------------------------------------------------
TBool CMceUi::FolderNameQueryL(
    const TInt aResourceId,
    TDes& aFolderName,
    const TMsvId aFolderId /*= KMsvNullIndexEntryId */ ) const
    {
    CAknTextQueryDialog* dlg = NULL;
    TInt button = 0;
    TBool okToStop = EFalse;
    while ( !okToStop )
        {
        dlg = CAknTextQueryDialog::NewL( aFolderName );
        dlg->SetMaxLength( KMceMaxFolderLength );
        button = dlg->ExecuteLD( aResourceId );
        if ( button )
            {
            MceUtils::ReplaceCharacters( aFolderName );
            if ( iMceListView->IsFolderNameUsedL( aFolderName, aFolderId ) )
                {
                HBufC* errorText = StringLoader::LoadLC(
                    R_MCE_DUPLICATE_FOLDER_TEXT, aFolderName, iEikonEnv );
                CAknInformationNote* note = new(ELeave)CAknInformationNote( ETrue );
                note->ExecuteLD(*errorText);
                CleanupStack::PopAndDestroy( errorText );
                }
            else
                {
                okToStop = ETrue;
                }
            }
        else
            {
            okToStop = ETrue;
            }
        }
    return button;
    }

// ----------------------------------------------------
// CMceUi::CloseConnectionsBeforeExitL
// ----------------------------------------------------
void CMceUi::CloseConnectionsBeforeExitL()
    {
    CMsvEntrySelection* connectedAccounts = ConnectedServicesLC();
    const TInt numberOfConnectedMailboxes = connectedAccounts->Count();
    TInt mceConnected = numberOfConnectedMailboxes;

    if ( iAlwaysOnline )
        {
        TMsvId account;
        TMsvEntry entry;
        TMsvId service;

        for ( TInt cc = 0; cc < numberOfConnectedMailboxes; cc++ )
            {
            account = connectedAccounts->At( cc );
            User::LeaveIfError( iSession->GetEntry(account,service,entry) );
// Get the allways online mail settings
            CImumInSettingsData* settings =
                iEmailApi->MailboxServicesL().LoadMailboxSettingsL( account );
            CleanupStack::PushL( settings );

            if ( !ServiceIdFound( account ) && 
                iMceMainView->ListContainer()->ListItems()->
                    AlwaysOnlineAccountL( account, *settings ) )
                {
                //this is a real always online account and not connected from mce
                mceConnected--;
                }

            CleanupStack::PopAndDestroy( settings ); // extendedMailSettings
            }
        }

    if ( mceConnected > 0 )
        {
        TBool disconnectMailboxes = ETrue;
        if( iEmailClientIntegration && iSelectableEmail )
            {
            //no need to go through the disconnection logic since the FS is enabled
            disconnectMailboxes = EFalse;
            iMceUiFlags.SetMceFlag( EMceUiFlagsWantToExit );
            }
        else
        if ( MceViewActive( EMceMainViewActive )
            || ( MceViewActive( EMceMessageViewActive )
            && iMceListView->IsMSKMailBox() ) )
            {
        CAknQueryDialog* confDialog = CAknQueryDialog::NewL();
        confDialog->PrepareLC( R_MCE_CONFIRMATION );
        HBufC* titleText = NULL;
        if ( numberOfConnectedMailboxes == 1 )
            {
            titleText = StringLoader::LoadLC(
                R_MCE_CONNECTION_ON_TEXT,
                iEikonEnv );
            }
        else
            {
            titleText = StringLoader::LoadLC(
                R_MCE_CONNECTION_ON_MANY_TEXT,
                iEikonEnv );
            }

        confDialog->SetPromptL( *titleText );
        CleanupStack::PopAndDestroy( titleText );

            if ( !confDialog->RunLD() )
                {
                disconnectMailboxes = EFalse;
                }
            }
        if ( disconnectMailboxes )
            {
            iMceUiFlags.SetMceFlag( EMceUiFlagsExitAfterDisconnect  );
            for ( TInt loop = 0; loop < numberOfConnectedMailboxes; loop++ )
                {
                GoOfflineSynchronouslyL( connectedAccounts->At( loop ) );
                }
            if (iMceUiFlags.MceFlag( EMceUiFlagsExitAfterDisconnect ) )
                {
                iMceUiFlags.SetMceFlag( EMceUiFlagsWantToExit );
                }
            }
        }
    else
        {
        iMceUiFlags.SetMceFlag( EMceUiFlagsWantToExit );
        }
    CleanupStack::PopAndDestroy(); // connectedAccounts
    }

// ----------------------------------------------------
// CMceUi::ConnectedServicesLC
// ----------------------------------------------------
CMsvEntrySelection* CMceUi::ConnectedServicesLC()
    {
    MCELOGGER_ENTERFN("ConnectedServicesLC()");

    CMsvEntrySelection* connectedAccounts = new(ELeave) CMsvEntrySelection();
    CleanupStack::PushL(connectedAccounts);

    CMsvEntrySelection* sel = MsvUiServiceUtilities::GetListOfAccountsL(
        *iSession );
    CleanupStack::PushL( sel );
    const TUid  connectCapability={KUidMsvMtmUiQueryConnectionOrientedServices};

    CBaseMtmUiData* uiData=NULL;
    TUid uid;
    const TInt numAccounts=sel->Count();
    for (TInt cc=0; cc<numAccounts; cc++)
        {
        uid.iUid=sel->At(cc);
        const TMsvEntry& tentry=iRootEntry->ChildDataL(uid.iUid);

        TRAPD(error, ( uiData=GetMtmUiDataL(tentry.iMtm) ) );
        if (error==KErrNone && uiData)
            {
            TInt rid;
            if (uiData->QueryCapability(connectCapability, rid)==KErrNone)
                {
                if (tentry.Connected())
                    {
                    connectedAccounts->AppendL( sel->At(cc) );
                    }
                }
            }
        }
    CleanupStack::PopAndDestroy( sel );
    MCELOGGER_LEAVEFN("ConnectedServicesLC()");
    return connectedAccounts;
    }

// ----------------------------------------------------
// CMceUi::OpenFolderViewL
// ----------------------------------------------------
void CMceUi::OpenFolderViewL( TMsvId aFolderId )
    {
    iMceListView->SetFolderL( aFolderId );
    ActivateLocalViewL( KMceMessageListViewId );
    }

// ----------------------------------------------------
// CMceUi::OpenRemoteMailboxViewL
// ----------------------------------------------------
void CMceUi::OpenRemoteMailboxViewL( TMsvId aFolderId )
    {
        // NCN reset, if the mail folder contains unread messages
    TBool unreadMessages = EFalse;
#ifndef RD_MSG_NAVIPANE_IMPROVEMENT
	TRAPD(err, ( unreadMessages = iBitmapResolver->HasUnreadMessagesL(aFolderId) ) );
#else   
    TInt messageCount = 0;
    TInt unreadCount = 0;
    TRAPD(err, ( unreadMessages = iBitmapResolver->HasUnreadMessagesL(aFolderId, messageCount, unreadCount) ) );
#endif // RD_MSG_NAVIPANE_IMPROVEMENT     
    if (err == KErrNone && unreadMessages )
        {
        HandleNotif(aFolderId);
        }    
    OpenFolderViewL( aFolderId );
    ShowTabsL( aFolderId );
    }

// ----------------------------------------------------
// CMceUi::CancelMailboxTimer
// ----------------------------------------------------
void CMceUi::CancelMailboxTimer()
    {
    if ( iConnectMailboxTimer && iConnectMailboxTimer->IsActive() )
        {
        iConnectMailboxTimer->Cancel();
        }
    }

// ----------------------------------------------------
// CMceUi::EditMTMEntryL
// ----------------------------------------------------
void CMceUi::EditMTMEntryL( const TMsvEntry& aEntry /*, TBool aOpen*/)
    {
    // Define KPSUidMuiu property to be integer type
    TInt r = RProperty::Define( KPSUidMuiu, KMuiuKeyCurrentMsg, RProperty::EInt );
    if ( r != KErrAlreadyExists )
        {
        User::LeaveIfError( r );
        }
    // Set entry Id value to property
    if ( aEntry.iType == KUidMsvMessageEntry )
        {
        r = RProperty::Set( KPSUidMuiu, KMuiuKeyCurrentMsg, aEntry.Id() );
        }

    TBool tabsToCleanupStack = EFalse;
    delete iMessageIterator;
    iMessageIterator = NULL;
    if ( aEntry.iType == KUidMsvMessageEntry )
        {
        iMessageIterator = CMessageIterator::NewL( *iSession, aEntry );
        }

    CBaseMtmUi& mtmUi=iMtmStore->GetMtmUiAndSetContextLC( aEntry );
    mtmUi.SetPreferences( mtmUi.Preferences() | EMtmUiFlagEditorPreferEmbedded );

    CMsvOperation* op = NULL;
    CAknInputBlock::NewLC();

    CMsvSingleOpWatcher* singleOpWatcher=CMsvSingleOpWatcher::NewL( *this );
    CleanupStack::PushL( singleOpWatcher );
    if (aEntry.iType == KUidMsvMessageEntry )
        {
        MCELOGGER_WRITE_FORMAT("EditMTMEntryL: iEditorOperation set 0x%x", singleOpWatcher );
        iEditorOperation = singleOpWatcher;
        }
    CleanupStack::PushL( TCleanupItem( ResetEditorOperation, this ) );
    

    if ( aEntry.iType == KUidMsvServiceEntry )
        {
        if ( iMceUiFlags.MceFlag( EMceUiFlagsTabsActive ) )
            {
            // must remove tabs because if no mailboxes created then
            // mailbox settings dialog is displayed and tabs should not be shown then.
            RemoveTabs();
            CleanupStack::PushL( TCleanupItem( ShowTabs, this ) );
            tabsToCleanupStack = ETrue;
            }
        TAknUiZoom previous = ZoomLevelChangedL( EAknUiZoomAutomatic );
        op=mtmUi.EditL( singleOpWatcher->iStatus );
        ZoomLevelChangedL( previous );

        if ( tabsToCleanupStack )
            {
            CleanupStack::PopAndDestroy(); // TCleanupItem - will show tabs again
            }
        }
    else
        {

        ReleaseMtmUiData();

        TRAPD( error, ( op=mtmUi.OpenL(singleOpWatcher->iStatus ) ) );
        if ( error )
            {
            // the returned error ofCBaseMtmUi code is defined in e32err.h instead of DocumentHandler.h
            // KMimeNotSupported(-12003) and KErrNotSupported(-5) has same meaning but different value
            // Solution: add the corresponding error code from e32err.h : (KErrUnknown, KErrAccessDenied ?)
            if ( error == KMimeNotSupported || error == KBadMimeType || error == KExecNotAllowed
                || error == KErrNotSupported || error == KErrUnknown || error == KErrAccessDenied )
                {
                //cannot be opened, mark read
                CMsvEntry* cEntry;
                cEntry = &(mtmUi.BaseMtm().Entry());
                TMsvEntry entry = cEntry->Entry();
                entry.SetUnread( EFalse );
                cEntry->ChangeL( entry );
                }

            // HandleOpenL is Trapped in MceOneRowListContainer to show error note we need to do it by ourselves
             delete op; // op should be null if leave occurs but make sure it is not leaked.
             HBufC* buf = 0;
             HandleErrorL(error, &buf);
             delete buf;
             CleanupStack::PopAndDestroy( 4 ); 
             if (error && iLocalScreenClearer )
                 {
                 delete iLocalScreenClearer;
                 iLocalScreenClearer = NULL;
                 }
             return;
                         
            //User::Leave( error );
            }
            
        CMceMessageListContainerBase* listContainer = iMceListView->ListContainer();
        if ( listContainer )
            {
            listContainer->UpdateIconArrayL();
            }
            
    	// the check has been added for email mailbox, need not to clear the screen
    	if ( !iLocalScreenClearer &&
             !CheckTechnologyTypeFromMtm( KMailTechnologyTypeUid, aEntry.iMtm ))       
	        {
	        iLocalScreenClearer = CAknLocalScreenClearer::NewL( ETrue );
	        }            
        }

    CleanupStack::PushL( op );
    iOperations.AppendL( singleOpWatcher );
    CleanupStack::Pop( 3 ); // singleOpWatcher, ResetEditorOperation op
    singleOpWatcher->SetOperation( op );
    MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
    if ( aEntry.iType == KUidMsvMessageEntry &&
        iUiRegistry &&
        iUiRegistry->IsPresent( op->Mtm() ) )
        {
        iMtmStore->ClaimMtmUiL( aEntry.iMtm );            
        }
    CleanupStack::PopAndDestroy( 2 ); // CAknInputBlock, release mtmUi
    }

// ----------------------------------------------------
// CMceUi::CreateNewAccountL
// ----------------------------------------------------
TBool CMceUi::CreateNewAccountL(
    TUid aMessageType,
    TMsvId aOldServiceId /* = KMsvNullIndexEntryId */)
    {
    MCELOGGER_ENTERFN("CreateNewAccountL()");
    if ( aMessageType == KSenduiMtmSyncMLEmailUid )
    {
        aMessageType = KSenduiMtmSmtpUid;
    }

    iRootEntry->SetEntryL(KMsvRootIndexEntryIdValue);

    LeaveIfDiskSpaceUnderCriticalLevelL();

    TMsvEntry nentry;
    nentry.iMtm = aMessageType;
    nentry.iType.iUid = KUidMsvServiceEntryValue;
    nentry.iDate.HomeTime();
    nentry.iServiceId = aOldServiceId;

    // --- Get the MTM UI relevant to the message type ---
    CBaseMtmUi& mtmUi = iMtmStore->GetMtmUiLC( nentry.iMtm );
    CMsvEntry* centry = iSession->GetEntryL( KMsvRootIndexEntryId );
    CleanupStack::PushL( centry );
    CAknInputBlock::NewLC();

    CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL(*this);
    CleanupStack::PushL( singleOpWatcher );

    // Mailbox creation is ongoing, syncronic operation
    iMailboxCreationOn = ETrue;
    CMsvOperation* op = mtmUi.CreateL(
        nentry,
        *centry,
        singleOpWatcher->iStatus );
    // Mailbox creation finalized
    iMailboxCreationOn = EFalse;

    CleanupStack::PushL( op );
    iOperations.AppendL( singleOpWatcher );
    CleanupStack::Pop( 2 ); // singleOpWatcher, op
    singleOpWatcher->SetOperation( op );

    TBool accountCreated = (op->iStatus != KErrCancel);
    // if not created, imum returns completed operation with KErrCancel
    if ( accountCreated )
				{
        iMceMainView->ListContainer()->ListItems()->HandleSessionEventL( EMsvEntriesCreated, NULL, NULL, NULL );
				}

    CleanupStack::PopAndDestroy(); // CAknInputBlock
    CleanupStack::PopAndDestroy( centry );
    CleanupStack::PopAndDestroy(); // mtm ui release
    MCELOGGER_LEAVEFN("CreateNewAccountL()");
    return accountCreated;
    }

// ----------------------------------------------------
// CMceUi::EditAccountL
// ----------------------------------------------------
void CMceUi::EditAccountL(TMsvId aId)
    {

    iRootEntry->SetEntryL(KMsvRootIndexEntryIdValue);

    LeaveIfDiskSpaceUnderCriticalLevelL();

    TMsvEntry entry;

    CMsvEntrySelection* rootSel = iRootEntry->ChildrenL();
    CleanupStack::PushL( rootSel );
    const TInt index = rootSel->Find( aId );
    if (index > KErrNotFound)
        {
        entry = (*iRootEntry)[index];
        EditMTMEntryL( entry );
        }
    CleanupStack::PopAndDestroy( rootSel );
    }

// ----------------------------------------------------
// CMceUi::MtmAccountsL
// ----------------------------------------------------
CUidNameArray* CMceUi::MtmAccountsL( TUid aType )
    {

    iRootEntry->SetEntryL(KMsvRootIndexEntryIdValue);

    CUidNameArray* accounts = new (ELeave) CUidNameArray(
        KMceArrayGranularity );
    CleanupStack::PushL( accounts );

    CMsvEntrySelection* sel = NULL;

    if ( aType == KSenduiMtmSmtpUid )
        {
        sel = MsvUiServiceUtilities::GetListOfAccountsL(
            *iSession,
            ETrue );
        }
    else
        {
        sel = MsvUiServiceUtilities::GetListOfAccountsWithMTML(
            *iSession,
            aType,
            ETrue );
        }
    CleanupStack::PushL( sel );

    CMsvEntry* rootEntry = CMsvEntry::NewL(
        *iSession,
        KMsvRootIndexEntryId,
        TMsvSelectionOrdering(KMsvNoGrouping, EMsvSortByNone, ETrue));
    delete iRootEntry;
    iRootEntry = rootEntry;

    TUid uid;
    TUid techType = iUiRegistry->TechnologyTypeUid( aType );
    const TInt numAccounts = sel->Count();
    for (TInt cc=0; cc<numAccounts; cc++)
        {
        uid.iUid = sel->At(cc);
        TMsvEntry tentry;
        TRAPD( err, ( tentry = iRootEntry->ChildDataL( uid.iUid ) ) );
        if ( err == KErrNone &&
            iUiRegistry->IsPresent( tentry.iMtm ) && 
            iUiRegistry->TechnologyTypeUid( tentry.iMtm ) == techType )
            {
            const TInt count = accounts->Count();
            TBool foundService = EFalse;
            //check that related service is not already added to array
            for ( TInt loop = 0; loop < count; loop ++ )
                {
                if ( tentry.iRelatedId == (*accounts)[loop].iUid.iUid )
                    {
                    foundService = ETrue;
                    break;
                    }
                }
            if ( !foundService )
                {
                TUidNameInfo info( uid, tentry.iDetails.Left( KHumanReadableNameLength ) );
                MceUtils::ReplaceCharacters( info.iName );
                accounts->AppendL( info );
                }
            }
        }
    CleanupStack::PopAndDestroy( sel );
    CleanupStack::Pop( accounts );
    return accounts;
    }

// ----------------------------------------------------
// CMceUi::HandleDeleteL
// ----------------------------------------------------
void CMceUi::HandleDeleteL()
    {
    MCELOGGER_ENTERFN("HandleDeleteL()");

    __ASSERT_DEBUG( MceViewActive( EMceMessageViewActive ),
        Panic( EMceUiErrCannotDeleteFromMainView ) );
    if ( MceViewActive( EMceMainViewActive ) )
        {
        return;
        }

    CMsvEntrySelection * selection = iMceListView->ListContainer()
        ->CurrentItemSelectionL();
    CleanupStack::PushL( selection );
    __ASSERT_DEBUG( selection->Count() > 0,
        Panic( EMceUiErrCannotDeleteFromMainView ) );

    if (  selection->Count() <= 0 )
        {
        CleanupStack::PopAndDestroy( selection );
        return;
        }

    iMceListView->ListContainer()->SetAnchorItemIdL(
        CMceMessageListContainerBase::EMessageListOperationDelete );

    const TMsvId id = selection->At(0);
    iEntry->SetEntryL(id);
    const TInt type = iEntry->Entry().iType.iUid;

    if ( IsMessageSendingL( id ) )
        {
        CleanupStack::PopAndDestroy( selection );
        return;
        }

    __ASSERT_DEBUG( type == KUidMsvMessageEntryValue || type == KUidMsvFolderEntryValue,
        Panic(EMceUiErrCannotDeleteServiceFromMainView) );

    TBool local = iEntry->OwningService() == KMsvLocalServiceIndexEntryIdValue;

    if ( iMMSNotifications )
        {
        delete iMMSNotifications;
        iMMSNotifications = NULL;
        }

    if ( local && ( ( iEntry->Entry().Parent() == KMsvGlobalInBoxIndexEntryId ) ||
        ( iEntry->Entry().Parent() == KMsvGlobalOutBoxIndexEntryId ) ) ) 
        {
        CheckMMSNotificationsL( selection );
        if (  selection->Count() <= 0 )
            {
            // delete mms notifications, if any
            if ( iMMSNotifications->Count() > 0 )
                {
                //delete MMS notifications
                TBuf8<1> params;
                HandleMMSNotificationsDeleteL( params );
                }
            CleanupStack::PopAndDestroy( selection );
            return;
            }
        }

    if ( local )
        {
        CAknQueryDialog* confDialog = CAknQueryDialog::NewL();
        confDialog->PrepareLC( R_MCE_CONFIRMATION );
        // confDialog in CleanupStack now
        HBufC* titleText;
        if ( type == KUidMsvFolderEntryValue )
            {
            titleText = StringLoader::LoadLC( R_MCE_QUERY_COMMON_CONF_DELETE_FO,
                iEntry->Entry().iDetails.Left( iBitmapResolver->DescriptionLength() ), iEikonEnv );
            }
        else
            {
            if ( selection->Count() == 1 )
                {
                titleText = StringLoader::LoadLC(
                    R_MCE_QUERY_COMMON_CONF_DELETE_ME, iEikonEnv );
                }
            else
                {
                titleText = StringLoader::LoadLC(
                    R_MCE_QUERY_COMMON_CONF_DELETE_MS,
                    selection->Count(), iEikonEnv );
                }
            }
        confDialog->SetPromptL( *titleText );
        CleanupStack::PopAndDestroy( titleText );
        // RunLD removes confDialog from CleanupStack and deletes itself
        if ( !confDialog->RunLD() )
            {
            CleanupStack::PopAndDestroy( selection ); // selection
            return;
            }
        }
    iEntry->SetEntryL( iEntry->Entry().Parent() );

    CBaseMtmUi* ui = NULL;
    TUid mtm=iEntry->Entry().iMtm;
    if ( !local )
        {
        TRAPD(uiErr, (ui = &iMtmStore->ClaimMtmUiL( mtm )));
        if ( uiErr == KErrNotFound || uiErr == KErrNotSupported )
            {
            // MTM not present, so delete as normal local entry
            ui = NULL;
            }
        else
            {
            User::LeaveIfError(uiErr);
            }
        }
    if (ui)
        {
        CMtmStoreMtmReleaser::CleanupReleaseMtmUiLC(*iMtmStore, mtm);
        }

    CMsvOperation* op;

    if ( local )
        {
        __ASSERT_DEBUG( !iDeleteOperation,
            Panic( EMceUiErrAlreadyDeleting ) );

// Free disk space request for delete to be added
        }

    CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
    CleanupStack::PushL( singleOpWatcher );

    TBool resetSelection = ETrue;

    if (ui)
        {
        // reset ncn, if it is unread message
        TMsvEntry entry;
        TMsvId serviceId;
        User::LeaveIfError( iSession->GetEntry(selection->At(0),serviceId,entry) );
                
        if ( CheckTechnologyTypeFromMtm( KMailTechnologyTypeUid, 
                entry.iMtm )&& entry.Unread() )
            {
            HandleNotif(iMceListView->ListContainer()->FolderEntry().iServiceId);

            }
        
        ui->BaseMtm().SetCurrentEntryL(iSession->GetEntryL(
            iEntry->Entry().Id()));

        CAknInputBlock::NewLC();
        op = ui->DeleteFromL(*selection, singleOpWatcher->iStatus);
        SetViewUpdateSuppressionFlag( ETrue, op );
        CleanupStack::PopAndDestroy(); // CAknInputBlock
        CleanupStack::PushL( op );
        // if cancel was pressed then completed operation is returned with
        // local service and status KErrCancel
        if ( op->Service() == KMsvLocalServiceIndexEntryId &&
             op->iStatus == KErrCancel )
            {
            resetSelection = EFalse;
            SetViewUpdateSuppressionFlag( EFalse, NULL );
            }
        }
    else
        {
        if ( iEntry->EntryId() == KMsvGlobalOutBoxIndexEntryId )
            {
            CMsvProgressReporterOperation* progOp =
                CMsvProgressReporterOperation::NewL(
                *iSession, singleOpWatcher->iStatus, EMbmAvkonQgn_note_erased );
            CleanupStack::PushL( progOp );

            CMsvOperation* subOp = CMceCancelSendingOperation::NewL(
                *iSession,
                progOp->RequestStatus(),
                selection->At(0),
                CMceCancelSendingOperation::ECancelAndDelete,
                *iMtmStore );

            progOp->SetOperationL(subOp); // this takes ownership immediately, so no cleanupstack needed.

            HBufC* text = StringLoader::LoadLC(
                R_MUIU_LOCAL_PROGRESS_DELETING_1,
                iEikonEnv );
            progOp->SetTitleL( *text );
            CleanupStack::PopAndDestroy( text );
            op = progOp;
            }
        else
            {
            // SMS and MMS deletion
            if ( selection->Count() > KMceProgressReporterThreshold ||
                 type == KUidMsvFolderEntryValue )
                {
                // Show the progress note

                CMsvProgressReporterOperation* progOp =
                    CMsvProgressReporterOperation::NewL(
                    *iSession, singleOpWatcher->iStatus, EMbmAvkonQgn_note_erased );

                CleanupStack::PushL( progOp );

                // deleting folder
                HBufC* text = NULL;
                iEntry->SetEntryL(id);

                if( type == KUidMsvFolderEntryValue )
                    {
                    text = StringLoader::LoadLC( R_MCE_WAIT_DELETE_FOLDER,
                        iEntry->Entry().iDetails.Left( iBitmapResolver->DescriptionLength() ),
                        iEikonEnv );
                    }
                else // if message
                    {
                    text = StringLoader::LoadLC(
                        R_MUIU_LOCAL_PROGRESS_DELETING_1,
                        iEikonEnv );
                    }
                progOp->SetTitleL( *text );
                CleanupStack::PopAndDestroy( text );
                iEntry->SetEntryL( iEntry->Entry().Parent() );

                CMsvOperation* subOp=iEntry->DeleteL(
                    *selection, progOp->RequestStatus() );
                progOp->SetOperationL(subOp); // this takes ownership immediately, so no cleanup stack needed.
                op = progOp;
                }
            else
                {
                // Do not show the progress note
                iEntry->SetEntryL(id);
                iEntry->SetEntryL( iEntry->Entry().Parent() );
                op = iEntry->DeleteL( *selection, singleOpWatcher->iStatus );
                CleanupStack::PushL( op );
                }
            }
        }

    iOperations.AppendL( singleOpWatcher );
    CleanupStack::Pop( 2, singleOpWatcher ); // singleOpWatcher, op
    singleOpWatcher->SetOperation( op );
    MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );

    if ( ui )
        {
        CleanupStack::PopAndDestroy( );// release mtmUi
        }
    if ( local )
        {
        // if deleting from service, then it is mtm's responsibility to free disk...
        iDeleteOperation = singleOpWatcher;
        MCELOGGER_WRITE_FORMAT("free disk requested, iDeleteOperation set 0x%x", iDeleteOperation );

// Cancel the free disk space request to be added
        }
    CleanupStack::PopAndDestroy( selection );
    if ( resetSelection )
        {
        iMceListView->ListContainer()->ClearSelection();
        }
    iMsgDeletedStatus = ETrue;
    MCELOGGER_LEAVEFN("HandleDeleteL()");
    }

// ----------------------------------------------------
// CMceUi::HandleUndeleteL
// ----------------------------------------------------
void CMceUi::HandleUndeleteL()
    {
    MCELOGGER_ENTERFN("HandleUndeleteL()");

    __ASSERT_DEBUG( MceViewActive( EMceMessageViewActive ),
        Panic( EMceUiErrCannotUnDeleteFromMainView ) );
    if ( MceViewActive( EMceMainViewActive ) )
        {
        return;
        }

    CMsvEntrySelection* selection = iMceListView->ListContainer()
        ->CurrentItemSelectionRefreshL();
    CleanupStack::PushL( selection );

    const TInt count = selection->Count();
    __ASSERT_DEBUG( count != 0, Panic( EMceErrNothingToUnDelete ) );
    if ( count == 0 )
        {
        CleanupStack::PopAndDestroy( selection );
        return;
        }

    const TMsvId id = selection->At( 0 );
    TBool resetSelection = ETrue;

    TMsvEntry tentry;
    GetEntryL( id, tentry );
    TMsvEntry parentEntry;
    GetEntryL( tentry.Parent(), parentEntry );

    CBaseMtmUi& ui = iMtmStore->GetMtmUiAndSetContextLC( parentEntry );

    CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
    CleanupStack::PushL(singleOpWatcher);

    CAknInputBlock::NewLC();
    CMsvOperation* op = ui.UnDeleteFromL(*selection, singleOpWatcher->iStatus);
    CleanupStack::PopAndDestroy(); // CAknInputBlock::NewLC()
    CleanupStack::PushL( op );
    // if cancel was pressed then completed operation is returned with
    // local service and status KErrCancel
    if ( op->Service() == KMsvLocalServiceIndexEntryId &&
         op->iStatus == KErrCancel )
        {
        resetSelection = EFalse;
        }

    iOperations.AppendL( singleOpWatcher );
    CleanupStack::Pop( 2 ); // singleOpWatcher, op
    singleOpWatcher->SetOperation( op );
    MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );

    CleanupStack::PopAndDestroy( 2 );// release mtmUi, selection
    if ( resetSelection )
        {
        iMceListView->ListContainer()->ClearSelection();
        }
    MCELOGGER_LEAVEFN("HandleUndeleteL()");
    }

// ----------------------------------------------------
// CMceUi::MoveOrCopyEntriesL
// ----------------------------------------------------
void CMceUi::MoveOrCopyEntriesL( TBool aCopy )
    {
    TInt count;
    TMsvId id;
    TMsvId service;
    TMsvEntry tEntry;
    TBool mailMessage = EFalse;
    if ( aCopy )
        {
        LeaveIfDiskSpaceUnderCriticalLevelL( iDiskSpaceForMoveOrCopy );
        }
    else
        {
        LeaveIfDiskSpaceUnderCriticalLevelL();
        }

    __ASSERT_DEBUG( MceViewActive( EMceMessageViewActive ),
        Panic( EMceUiErrCannotMoveFromMainView ) );
    if ( MceViewActive( EMceMainViewActive ) )
        {
        return;
        }

    const TMsvId sourceId = iMceListView->ListContainer()->CurrentFolderId();

    CMsvEntrySelection * selection = iMceListView->ListContainer()
        ->CurrentItemSelectionL();
    CleanupStack::PushL( selection );

    if ( !aCopy )
        {
        count = selection->Count();
        // MMS notifications cannot be moved
        for ( TInt cc = count; --cc >= 0; )
            {
            id = selection->At( cc );
            if ( iSession->GetEntry( id, service, tEntry ) == KErrNone  )
                {
                if ( tEntry.iMtm == KUidMsgMMSNotification )
                    {
                    selection->Delete( cc );
                    }
                }
            }
        if ( selection->Count() < count )
            {
            // MMS notifications have been deleted from selection
            CAknQueryDialog* note = CAknQueryDialog::NewL();
            HBufC* text = NULL;
            text = StringLoader::LoadLC( R_MMS_INFO_CANNOT_MOVE_NOTIF, CCoeEnv::Static() );
            note->SetPromptL( *text );
            CleanupStack::PopAndDestroy( text );
            note->ExecuteLD( R_MCE_MEMC_NOTE );
            }
        }

    // Email messages cannot be moved
    iMoveOrCopyMailOperation = -1;
    mailMessage = RemoveEmailMessagesFromSelection( selection );

    if (  selection->Count() <= 0 )
        {
        CleanupStack::PopAndDestroy( selection );
        if ( mailMessage )
            {
            InformationNoteCannotMoveCopyEMailL();
            }
        return;
        }
// Find an iAnchorId (=itemId) that should be focused after moving some items from the list
    iMceListView->ListContainer()->SetAnchorItemIdL(
        CMceMessageListContainerBase::EMessageListOperationGeneral );

    TMsvId destinationId = sourceId;
    const TInt titleResourceId = aCopy ?
        R_MCE_COPY_MESSAGES :
        R_MCE_MOVE_MESSAGES;
    HBufC* text =  StringLoader::LoadLC( titleResourceId, iEikonEnv );

    const TInt iconId = aCopy ?
        EMbmAvkonQgn_note_move :
        EMbmAvkonQgn_note_copy;

    if ( CMsgFolderSelectionDialog::SelectFolderL( destinationId, *text ) )
        {
        // Trap: NCNList cannot seperate New and Unread that comes to Inbox
        // So when movning Unread msgs to Inbox, we need to change them to
        // read, and then change them back after moving is completed
        if ( destinationId == KMsvGlobalInBoxIndexEntryId )
            {
            HandleNewMsgToInboxL( ETrue, selection );
            }

        TMsvEntry srcEntry;
        const TBool sourceIsRemote = KMsvLocalServiceIndexEntryId != GetEntryL( sourceId, srcEntry);

        CMsvOperation* op=NULL;

        CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
        CleanupStack::PushL( singleOpWatcher );

        CAknInputBlock::NewLC();

        TMsvId service = KMsvLocalServiceIndexEntryId;
        TMsvEntry sourceServiceEntry;
        User::LeaveIfError( iSession->GetEntry( srcEntry.iServiceId, service, sourceServiceEntry ) );

        if ( ( sourceIsRemote && !( sourceServiceEntry.Connected() ) ) ||
            ( sourceServiceEntry.iMtm == KSenduiMtmSyncMLEmailUid ) )
            {
            CBaseMtmUi& ui=iMtmStore->GetMtmUiAndSetContextLC( srcEntry );
            op=ui.CopyFromL( *selection, destinationId, singleOpWatcher->iStatus);
            CleanupStack::PopAndDestroy(); // release ui
            }
        else
            {
            CMsvProgressReporterOperation* progOp =
                CMsvProgressReporterOperation::NewL( *iSession, singleOpWatcher->iStatus, iconId );
            CleanupStack::PushL(progOp);
            CMsvOperation* subOp = NULL;
            iEntry->SetEntryL( sourceId );

            if ( aCopy )
                {
                subOp = iEntry->CopyL( *selection, destinationId, progOp->RequestStatus());
                }
            else
                {
                subOp = iEntry->MoveL( *selection, destinationId, progOp->RequestStatus());
                }

            progOp->SetOperationL( subOp ); // this takes ownership immediately, so no cleanupstack needed.
            op = progOp;
            CleanupStack::Pop( progOp ); 
            }

        CleanupStack::PopAndDestroy(); // CAknInputBlock
        CleanupStack::PushL( op );
        iOperations.AppendL( singleOpWatcher );
        CleanupStack::Pop( 2 ); // singleOpWatcher, op
        singleOpWatcher->SetOperation( op );
        MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );

        if ( mailMessage )
            {
            // Mail messages cannot be copied or moved, save the command ID
            iMoveOrCopyMailOperation = op->Id();
            }

        iMceListView->ListContainer()->ClearSelection();

        } // end if
    CleanupStack::PopAndDestroy( 2 ); // text, selection
    }

// ----------------------------------------------------
// CMceUi::ActivateLocalViewL
// ----------------------------------------------------
void CMceUi::ActivateLocalViewL(TUid aViewId)
    {
    if ( aViewId == KMceMainViewListViewId )
        {
        iEditorOperation = NULL;
        CAknTitlePane* title=TitlePaneL();
        HBufC* text = StringLoader::LoadLC( R_MCE_MAIN_VIEW_TITLE, iEikonEnv );
        title->SetTextL( *text );
        CleanupStack::PopAndDestroy(); // text
        }
    CAknViewAppUi::ActivateLocalViewL( aViewId );
    }

// ----------------------------------------------------
// CMceUi::CreateTabsL
// ----------------------------------------------------
void CMceUi::CreateTabsL()
    {
    MCELOGGER_ENTERFN("CreateTabsL()");
    __ASSERT_DEBUG( !iTabsArray, Panic( EMceUiErrTabsArrayAlreadyExists ) );

    delete iDecoratedTabGroup;
    iDecoratedTabGroup = NULL;
    iDecoratedTabGroup = iNaviPane->CreateTabGroupL( this );
    iDecoratedTabGroup->SetControlType( CAknNavigationDecorator::ETabGroup );

    CAknTabGroup* tabGroup = ( CAknTabGroup* ) iDecoratedTabGroup->DecoratedControl();

    CMceMainViewListItemArray* array = iMceMainView->ListContainer()->ListItems();
    TInt count = array->Count();
    CMsvEntrySelection* tabsArray = new( ELeave ) CMsvEntrySelection();
    CleanupStack::PushL( tabsArray );
    TInt loop = 0;
    for ( loop = 0; loop < count; loop++ )
        {
        const TMceListItem& listItem = (*array)[loop];
        if ( !listItem.iExtraItem || listItem.iMsvId == KMceDeliveryReportsListIdValue )
            {
              if (( iEmailClientIntegration )&&(!iEmailFramework))
              {
                TMsvId service;
                TMsvEntry entry;
                     
                  
                CRepository* repository = NULL;
                TInt mtmPluginID = 0;
                TRAPD( ret, repository = CRepository::NewL(
                                         KCRUidSelectableDefaultEmailSettings ) );
                
                if ( ret == KErrNone )
                    {
                    // Get Email application mtm plugin ID
                    repository->Get( KIntegratedEmailAppMtmPluginId, mtmPluginID );
                    }
                delete repository;
                if ( iSession->GetEntry(listItem.iMsvId, service, entry) == KErrNone
                                                    &&  entry.iMtm.iUid != mtmPluginID)
                 {
                 tabsArray->AppendL( listItem.iMsvId );
                 }
				else if(listItem.iMsvId == KMceDeliveryReportsListIdValue)
                 {
                 	tabsArray->AppendL( listItem.iMsvId );
                 }
               }
               else
               {
                 tabsArray->AppendL( listItem.iMsvId );
               }
            
            }
        }
    CleanupStack::Pop( tabsArray );
    iTabsArray = tabsArray;

    CFbsBitmap* bitmap;
    CFbsBitmap* bitmapMask;

    TAknsItemID id;
    id.iMajor = 0;
    id.iMinor = 0;

    MAknsSkinInstance* skins = AknsUtils::SkinInstance();

    count = iTabsArray->Count();
    TInt bitmapIndex = EMbmMuiuQgn_prop_mce_inbox_tab4;
    for ( loop = 0; loop < count; loop++ )
        {
        switch ( (*iTabsArray)[loop] )
            {
            case KMsvGlobalInBoxIndexEntryId:
                bitmapIndex = EMbmMuiuQgn_prop_mce_inbox_tab4;
                id = KAknsIIDQgnPropMceInboxTab4;
                break;
            case KMceDocumentsEntryId:
                bitmapIndex = EMbmMuiuQgn_prop_mce_doc_tab4;
                id = KAknsIIDQgnPropMceDocTab4;
                break;
            case KMsvDraftEntryId:
                bitmapIndex = EMbmMuiuQgn_prop_mce_drafts_tab4;
                id = KAknsIIDQgnPropMceDraftsTab4;
                break;
            case KMsvSentEntryId:
                bitmapIndex = EMbmMuiuQgn_prop_mce_sent_tab4;
                id = KAknsIIDQgnPropMceSentTab4;
                break;
            case KMsvGlobalOutBoxIndexEntryId:
                bitmapIndex = EMbmMuiuQgn_prop_mce_outbox_tab4;
                id = KAknsIIDQgnPropMceOutboxTab4;
                break;
            case KMceDeliveryReportsListIdValue:
                bitmapIndex = EMbmMuiuQgn_prop_mce_dr_tab4;
                id = KAknsIIDQgnPropMceDrTab4;
                break;
            default:
                {
                TMsvId service;
                TMsvEntry entry;
                if ( iSession->GetEntry( (*iTabsArray)[loop], service, entry) == KErrNone
                    && ( entry.iMtm == KSenduiMtmImap4Uid || entry.iMtm == KSenduiMtmPop3Uid )
                    && entry.Connected() )
                    {
                    bitmapIndex = EMbmMuiuQgn_prop_mce_remote_on_tab4;
                    id = KAknsIIDQgnPropMceRemoteOnTab4;
                    }
                else
                    {
                    bitmapIndex = EMbmMuiuQgn_prop_mce_remote_tab4;
                    id = KAknsIIDQgnPropMceRemoteTab4;
                    }
                }
                break;
            }

        AknsUtils::CreateIconL( skins, id, bitmap,
           bitmapMask, iFilename, bitmapIndex,
           bitmapIndex + 1 );

        tabGroup->AddTabL(
            loop, bitmap, bitmapMask );
        }

    tabGroup->SetTabFixedWidthL(KTabWidthWithFourTabs);

    MCELOGGER_LEAVEFN("CreateTabsL()");
    }

// ----------------------------------------------------
// CMceUi::CheckRemoteMailboxTabIconsL
// ----------------------------------------------------
void CMceUi::CheckRemoteMailboxTabIconsL()
    {
    MCELOGGER_ENTERFN("CheckRemoteMailboxTabIconsL()");
    __ASSERT_DEBUG( iMceUiFlags.MceFlag( EMceUiFlagsTabsActive ),
        Panic( EMceUiErrTabsNotActivated ) );
    __ASSERT_DEBUG( iTabsArray, Panic( EMceUiErrTabsArrayDoesNotAlreadyExist ) );
    CAknTabGroup* tabGroup = ( CAknTabGroup* ) iDecoratedTabGroup->DecoratedControl();
    const TInt count = iTabsArray->Count();
    for ( TInt loop = 0; loop < count; loop++ )
        {
        TMsvId service;
        TMsvEntry entry;
        if ( iSession->GetEntry( (*iTabsArray)[loop], service, entry) == KErrNone  )
            {
            TInt bitmapIndex = KErrNotFound;
            TAknsItemID id;
            id.iMajor = 0;
            id.iMinor = 0;
            if ( ( entry.iMtm == KSenduiMtmImap4Uid
            || entry.iMtm == KSenduiMtmPop3Uid ) )
            {
                bitmapIndex = entry.Connected() ?
                EMbmMuiuQgn_prop_mce_remote_on_tab4 : EMbmMuiuQgn_prop_mce_remote_tab4;
                id = entry.Connected() ?
                    KAknsIIDQgnPropMceRemoteOnTab4 : KAknsIIDQgnPropMceRemoteTab4;
                }
            else if ( entry.iMtm == KSenduiMtmSyncMLEmailUid )
                {
                bitmapIndex = EMbmMuiuQgn_prop_sml_remote_tab4;
                id = KAknsIIDQgnPropSmlRemoteTab4;
                }

            if ( bitmapIndex > KErrNotFound )
                {
                MAknsSkinInstance* skins = AknsUtils::SkinInstance();
                CFbsBitmap* bitmap;
                CFbsBitmap* bitmapMask;

                AknsUtils::CreateIconL( skins, id, bitmap,
                    bitmapMask, iFilename, bitmapIndex, bitmapIndex + 1 );

                tabGroup->ReplaceTabL(
                    loop, bitmap, bitmapMask );
                }
            }
        }

    MCELOGGER_LEAVEFN("CheckRemoteMailboxTabIconsL()");
    }

// ----------------------------------------------------
// CMceUi::ShowTabsL
// ----------------------------------------------------
void CMceUi::ShowTabsL( TMsvId aOpenedId, TBool aOpeningDeliveryReports /* = EFalse */ )
    {
    MCELOGGER_ENTERFN("ShowTabsL()");

    if ( !iDecoratedTabGroup )
        {
        CreateTabsL();
        }

    TInt selectedIndex;
    if ( aOpeningDeliveryReports )
        {
        selectedIndex = iTabsArray->Find( KMceDeliveryReportsListIdValue );
        }
    else
        {
        selectedIndex = iTabsArray->Find( aOpenedId );
        }

    CAknTabGroup* tabGroup = ( CAknTabGroup* ) iDecoratedTabGroup->DecoratedControl();
    tabGroup->SetActiveTabByIndex( selectedIndex );
    iNaviPane->PushL(*iDecoratedTabGroup);
    iMceUiFlags.SetMceFlag( EMceUiFlagsTabsActive );
    CheckRemoteMailboxTabIconsL();
    MCELOGGER_LEAVEFN("ShowTabsL()");
    }

// ----------------------------------------------------
// CMceUi::RemoveTabs
// ----------------------------------------------------
void CMceUi::RemoveTabs()
    {
    MCELOGGER_ENTERFN("RemoveTabs()");
    if ( iMceUiFlags.MceFlag( EMceUiFlagsTabsActive ) )
        {
        iNaviPane->Pop();
        iMceUiFlags.ClearMceFlag( EMceUiFlagsTabsActive );
        }
    MCELOGGER_LEAVEFN("RemoveTabs()");
    }

// ----------------------------------------------------
// CMceUi::RemoveTabsAndUpdateArray
// ----------------------------------------------------
void CMceUi::RemoveTabsAndUpdateArray()
    {
    MCELOGGER_ENTERFN("RemoveTabsAndUpdateArray()");
    TBool tabsActive = iMceUiFlags.MceFlag( EMceUiFlagsTabsActive );
    RemoveTabs();
    delete iDecoratedTabGroup;
    iDecoratedTabGroup = NULL;
    delete iTabsArray;
    iTabsArray = NULL;
    
    if ( tabsActive && MceViewActive( EMceMessageViewActive ) && iMceListView )
        {
        TRAP_IGNORE( ShowTabsL( iMceListView->ListContainer()->CurrentFolderId() ) );
        }
    MCELOGGER_LEAVEFN("RemoveTabsAndUpdateArray()");
    }

// ----------------------------------------------------
// CMceUi::CheckIAUpdate
// ----------------------------------------------------
void CMceUi::CheckIAUpdate()
    {
    iMceIAUpdate->StartL( TUid::Uid( KMceApplicationUidValue ) );
    }

// ----------------------------------------------------
// CMceUi::GoOnlineWithQueryL
// ----------------------------------------------------
void CMceUi::GoOnlineWithQueryL( TMsvId aAccount )
    {
    if ( AlwaysOnlineLastConnectionL( aAccount ) )
        {
        CAknQueryDialog* confDialog = CAknQueryDialog::NewL();
        if ( confDialog->ExecuteLD( R_MCE_GO_ONLINE_CONFIRMATION ) )
            {
            ChangeServiceConnectionStateL( aAccount, ETrue);
            }
        }
    }

// ----------------------------------------------------
// CMceUi::GoOnlineL
// ----------------------------------------------------
void CMceUi::GoOnlineL( TMsvId aAccount )
    {
    MCELOGGER_ENTERFN("GoOnlineL()");
    ChangeServiceConnectionStateL( aAccount, ETrue);
    MCELOGGER_LEAVEFN("GoOnlineL()");
    }

// ----------------------------------------------------
// CMceUi::CloseConnectionWithListQueryL
// ----------------------------------------------------
void CMceUi::CloseConnectionWithListQueryL()
    {
    CMsvEntrySelection* connectedAccounts = ConnectedServicesLC();
    const TInt numberOfConnectedMailboxes = connectedAccounts->Count();
    TInt closeConnection = KErrNotFound;

    if ( numberOfConnectedMailboxes > 0 )
        {
        if ( numberOfConnectedMailboxes == 1 )
            {
            closeConnection = 0;
            }
        else
            {
            CDesCArrayFlat* items = new(ELeave)CDesCArrayFlat( KMceArrayGranularity );
            CleanupStack::PushL( items );
            for (TInt loop = 0; loop < numberOfConnectedMailboxes; loop++)
                {
                const TMsvEntry& tentry=iRootEntry->ChildDataL( connectedAccounts->At( loop ) );
                items->AppendL( tentry.iDetails.Left( iBitmapResolver->DescriptionLength() ) );
                }

            CAknListQueryDialog* dlg = new (ELeave) CAknListQueryDialog(&closeConnection);
            dlg->PrepareLC( R_MCE_LIST_QUERY );
            dlg->SetItemTextArray( items );
            dlg->SetOwnershipType( ELbmDoesNotOwnItemArray );
            if( !dlg->RunLD() )
                {
                closeConnection = KErrNotFound;
                }
            CleanupStack::PopAndDestroy( items );
            }

        if ( closeConnection != KErrNotFound )
            {
            GoOfflineL( connectedAccounts->At( closeConnection ) );
            }
        }
    CleanupStack::PopAndDestroy(); // connectedAccounts

    }

// ----------------------------------------------------
// CMceUi::GoOfflineL
// ----------------------------------------------------
void CMceUi::GoOfflineL( TMsvId aAccount )
    {
    MCELOGGER_ENTERFN("GoOfflineL()");
    TMsvEntry tentry;
    GetEntryL( aAccount, tentry );
    if ( tentry.Connected() )
        {
        ChangeServiceConnectionStateL( aAccount, EFalse );
        }
    MCELOGGER_LEAVEFN("GoOfflineL()");
    }

// ----------------------------------------------------
// CMceUi::ChangeServiceConnectionStateL
// ----------------------------------------------------
void CMceUi::ChangeServiceConnectionStateL(TMsvId aServiceId, TBool aConnect)
    {
    MCELOGGER_ENTERFN("ChangeServiceConnectionStateL()");

    if ( aConnect )
        {
        LeaveIfDiskSpaceUnderCriticalLevelL();
        }

    TMsvEntry tentry;
    (void)GetEntryL(aServiceId, tentry);
    CBaseMtmUi& ui = iMtmStore->GetMtmUiAndSetContextLC(tentry);
    CMsvOperation* op;
    CAknInputBlock::NewLC();

    CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
    CleanupStack::PushL( singleOpWatcher );

    if ( aConnect )
        {
        op = ui.OpenL( singleOpWatcher->iStatus );
        if ( tentry.iMtm != KSenduiMtmImap4Uid )
            {
            SetViewUpdateSuppressionFlag( ETrue, op );
            }
        if ( iAlwaysOnline && op )
            {
            AddOperationIdL( op->Id(), aServiceId );
            }
        }
    else
        {
        op = ui.CloseL( singleOpWatcher->iStatus );
        if ( iAlwaysOnline && op )
           {
           RemoveOperationId( op->Id(), aServiceId );
           }
        }

    CleanupStack::PushL( op );

    iOperations.AppendL( singleOpWatcher );
    CleanupStack::Pop( 2 ); // singleOpWatcher, op
    singleOpWatcher->SetOperation( op );
    MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );

    CleanupStack::PopAndDestroy( 2 ); // CAknInputBlock, release mtmUi
    if ( iMceListView->ListContainer() && 
        ( MceViewActive(EMceMessageViewActive ) ) )
        {
        if ( aConnect )
            {
            iMceListView->ListContainer()->SetAnchorItemIdL(
                CMceMessageListContainerBase::EMessageListOperationConnect );
            }
        else
            {
            iMceListView->ListContainer()->SetAnchorItemIdL(
                CMceMessageListContainerBase::EMessageListOperationGeneral );
            }
        }

    MCELOGGER_LEAVEFN("ChangeServiceConnectionStateL()");
    }

// ----------------------------------------------------
// CMceUi::GetEntryL
// ----------------------------------------------------
TMsvId CMceUi::GetEntryL(TMsvId aId, TMsvEntry& aEntry) const
    {
    TMsvId service;
    User::LeaveIfError(iSession->GetEntry(aId, service, aEntry));
    return service;
    }

// ----------------------------------------------------
// CMceUi::SendSelectionL
// ----------------------------------------------------
void CMceUi::SendSelectionL(CMsvEntrySelection* aSel)
    {
    CleanupStack::PushL(aSel);
    CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
    CleanupStack::Pop( aSel ); 
    CleanupStack::PushL( singleOpWatcher ); // guaranteed not to leave because of previous pop

    CMsvOperation* op = CMceSendOperation::NewL(
        *iSession, singleOpWatcher->iStatus, *iMtmStore, aSel );
        // aSel will be deleted!

    CleanupStack::PushL( op );
    iOperations.AppendL( singleOpWatcher );
    CleanupStack::Pop( 2 ); // singleOpWatcher, op
    singleOpWatcher->SetOperation( op );
    MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
    }

// ----------------------------------------------------
// CMceUi::SendNowL
// ----------------------------------------------------
void CMceUi::SendNowL()
    {

    CMsvEntrySelection * selection = iMceListView->ListContainer()
        ->CurrentItemSelectionL();
    if ( selection->Count() == 0 )
        {
        delete selection;
        return;
        }

    CleanupStack::PushL( selection );

    // if we are sending email just ignore offline checks
    iEntry->SetEntryL( (*selection)[0] );
    const TMsvEntry& entry = iEntry->Entry();

    if ( entry.iMtm != KSenduiMtmSmtpUid &&
        FeatureManager::FeatureSupported( KFeatureIdOfflineMode ))
        {
        // check if offline mode has been set
        TInt offline = 1;

        CRepository* repository = NULL;
        TRAPD( ret, repository = CRepository::NewL(KCRUidCoreApplicationUIs) );
        CleanupStack::PushL( repository );

        if ( ret == KErrNone )
            {
            if ( repository->Get(KCoreAppUIsNetworkConnectionAllowed,offline) != KErrNone )
                {
                offline = 1;
                }
            }

        CleanupStack::Pop( repository );
        delete repository;

        if ( !offline )
            {
            // offline mode has been set
            HBufC* text = StringLoader::LoadLC( R_MCE_OFFLINE_NOT_POSSIBLE, CCoeEnv::Static() );
            CAknInformationNote* note = new (ELeave) CAknInformationNote();
            note->ExecuteLD(*text);
            CleanupStack::PopAndDestroy(2); //text, selection
            return;
            }

        }

    CleanupStack::Pop( selection ); // this is because SendSelectionL pushes selection immediately
    SendSelectionL( selection );
    }

// ----------------------------------------------------
// CMceUi::CancelSendingL
// ----------------------------------------------------
void CMceUi::CancelSendingL()
    {
    CMsvEntrySelection * selection = iMceListView->ListContainer()
        ->CurrentItemSelectionL();
    CleanupStack::PushL( selection );

    if ( selection->Count() == 0 ||
         IsMessageSendingL( selection->At(0) ) )
        {
        CleanupStack::PopAndDestroy( selection );
        return;
        }

    CMsvSingleOpWatcher* singleOpWatcher=CMsvSingleOpWatcher::NewL( *this );
    CleanupStack::PushL( singleOpWatcher );

    CMsvOperation* op = CMceCancelSendingOperation::NewL(
        *iSession,
        singleOpWatcher->iStatus,
        selection->At( 0 ),
        CMceCancelSendingOperation::ECancelOnly,
        *iMtmStore );

    CleanupStack::PushL( op );
    iOperations.AppendL( singleOpWatcher );
    CleanupStack::Pop( 2 ); // singleOpWatcher, op
    singleOpWatcher->SetOperation( op );
    MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );

    CleanupStack::PopAndDestroy( selection );
    }

// ----------------------------------------------------
// CMceUi::FetchNewL
// ----------------------------------------------------
void CMceUi::FetchNewL()
    {
    DoAsyncFunctionOnCurrentContextL( KMtmUiFunctionFetchNew );
    iMceListView->ListContainer()->SetAnchorItemIdL(
        CMceMessageListContainerBase::EMessageListOperationFetchNew );
    }

// ----------------------------------------------------
// CMceUi::FetchSelectedL
// ----------------------------------------------------
void CMceUi::FetchSelectedL()
    {
    __ASSERT_DEBUG( MceViewActive( EMceMessageViewActive ),
        Panic( EMceUiErrCannotFetchFromMainView ) );
    if ( MceViewActive( EMceMainViewActive ) )
        {
        return;
        }

    CMsvEntrySelection* sel = iMceListView->ListContainer()
        ->CurrentItemSelectionL();

    if ( sel->Count() == 0 )
        {
        delete sel;
        return;
        }

    CleanupStack::PushL( sel );

    iMceListView->ListContainer()->SetAnchorItemIdL(
        CMceMessageListContainerBase::EMessageListOperationFetchSelected );
    DoAsyncFunctionOnCurrentContextL(KMtmUiFunctionFetchSelected, *sel);
    CleanupStack::PopAndDestroy( sel );
    }

// ----------------------------------------------------
// CMceUi::FetchAllL
// ----------------------------------------------------
void CMceUi::FetchAllL()
    {
    DoAsyncFunctionOnCurrentContextL(KMtmUiFunctionFetchAll);
    iMceListView->ListContainer()->SetAnchorItemIdL(
        CMceMessageListContainerBase::EMessageListOperationFetchSelected );
    }

// ----------------------------------------------------
// CMceUi::DoAsyncFunctionOnCurrentContextL
// ----------------------------------------------------
void CMceUi::DoAsyncFunctionOnCurrentContextL(TInt aFunctionId)
    {
    CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection();
    CleanupStack::PushL( sel );

    DoAsyncFunctionOnCurrentContextL(aFunctionId, *sel);

    CleanupStack::PopAndDestroy( sel );
    }

// ----------------------------------------------------
// CMceUi::DoAsyncFunctionOnCurrentContextL
// ----------------------------------------------------
void CMceUi::DoAsyncFunctionOnCurrentContextL(TInt aFunctionId, CMsvEntrySelection& aSelection)
    {
    DoAsyncFunctionL(aFunctionId, aSelection, iMceListView->ListContainer()->FolderEntry());
    }

// ----------------------------------------------------
// CMceUi::DoAsyncFunctionL
// ----------------------------------------------------
void CMceUi::DoAsyncFunctionL(TInt aFunctionId, const TMsvEntry& aContext)
    {
    CMsvEntrySelection* sel= new (ELeave) CMsvEntrySelection();
    CleanupStack::PushL( sel );
    DoAsyncFunctionL(aFunctionId, *sel, aContext);
    CleanupStack::PopAndDestroy( sel );
    }

// ----------------------------------------------------
// CMceUi::DoAsyncFunctionL
// ----------------------------------------------------
void CMceUi::DoAsyncFunctionL( TInt aFunctionId, CMsvEntrySelection& aSelection,
    const TMsvEntry& aContext)
    {
    LeaveIfDiskSpaceUnderCriticalLevelL();

    CBaseMtmUi& mtmUi = iMtmStore->GetMtmUiAndSetContextLC( aContext );

    TBuf8<1> blankParams;
    CMsvSingleOpWatcher* singleOpWatcher=CMsvSingleOpWatcher::NewL( *this );
    CleanupStack::PushL( singleOpWatcher );

    CMsvOperation* op = mtmUi.InvokeAsyncFunctionL( aFunctionId, aSelection,
        singleOpWatcher->iStatus, blankParams );

    if ( CheckTechnologyTypeFromMtm( KMailTechnologyTypeUid, aContext.iMtm ) &&
         (aFunctionId == KMtmUiFunctionFetchNew ||
          aFunctionId == KMtmUiFunctionFetchAll 
        ))
        {
        SetViewUpdateSuppressionFlag( ETrue, op );   
        }

    if ( iAlwaysOnline && op )
        {
        TMsvEntry tEntry;
        TMsvId serviceId;
        User::LeaveIfError( iSession->GetEntry( aContext.iServiceId, serviceId, tEntry ) );
        if ( !tEntry.Connected() )
            {
            AddOperationIdL( op->Id(), serviceId );
            }
        }

    CleanupStack::PushL( op );
    iOperations.AppendL( singleOpWatcher );
    CleanupStack::Pop( 2 ); // singleOpWatcher, op
    singleOpWatcher->SetOperation( op );

    if ( aFunctionId == KMtmUiFunctionFetchNew )
        {
        iFetchNewOperation = singleOpWatcher;
        }

    MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );

    CleanupStack::PopAndDestroy(); // release mtmUI
    iMceListView->ListContainer()->ClearSelection();
    }

// ----------------------------------------------------
// CMceUi::AddMTMFunctionsL
// ----------------------------------------------------
void CMceUi::AddMTMFunctionsL(CEikMenuPane& aMenuPane, TInt aMenuCommandId)
    {
    MCELOGGER_ENTERFN("AddMTMFunctionsL()");
    TMsvEntry selectedEntry;
    TBool foundSelectedEntry = GetCurrentEntryL( selectedEntry );
    TMsvEntry openedEntry;
    TBool foundOpenedEntry = GetCurrentEntryL( openedEntry, ETrue );

    CEikMenuPaneItem::SData data;
    data.iCascadeId=0;
    data.iFlags=0;
    TInt cc;
    TInt sendCmd = EMceCmdFirstMTMFunction;
    const TInt count = iMTMFunctionsArray->Count();
    for ( cc = 0; cc < count; cc++ )
        {
        TMsgFunctionInfo& functionInfo = iMTMFunctionsArray->At(cc);
        data.iText = functionInfo.iCaption;
        data.iCommandId = sendCmd;
        if ( functionInfo.iFlags & EMtudContextSpecific )
            {
            if ( ( foundSelectedEntry && !CheckCommandAvailableL( sendCmd, selectedEntry ) ) ||
                 ( foundOpenedEntry && !CheckCommandAvailableL( sendCmd, openedEntry ) )
                )
                {
                if ( functionInfo.iFuncId == KMtmUiFunctionMessageInfo )
                    {
					sendCmd++;
					continue;
                    }

                else if ( functionInfo.iFuncId == KMtmUiFunctionDeliveryStatus )
                    {
                    data.iFlags |= EEikMenuItemSpecific;               
                    aMenuPane.AddMenuItemL( data, EMceCmdUndelete );
                    }

                else if ( functionInfo.iFuncId == KMtmUiFunctionFetchMMS ) //MMS notification
                    {
                    data.iFlags |= EEikMenuItemSpecific; 
                    aMenuPane.AddMenuItemL( data, EAknCmdOpen );
                    }

                else if ( functionInfo.iFuncId == KMtmUiFunctionFetchSyncML ) //SyncML Retrieve
                    {
                    if ( selectedEntry.iMtm == KSenduiMtmSyncMLEmailUid )
                        {
                        aMenuPane.AddMenuItemL( data, EAknCmdOpen );
                        }
                    else
                        {
                        // nothing is added
                        }
                    }

                else if ( functionInfo.iFuncId == KMtmUiFunctionMMBox )
                    {
                    aMenuPane.AddMenuItemL( data, EAknCmdOpen );
                    }

                else
                    {
                    // Following comparison added to hide MCE's Mark as read/Unread 
                    // as duplicate copy of same options was provided by Visto MTM
                    CCoeEnv* ownEikonEnvmak = CEikonEnv::Static();
                    HBufC* markasRead = ownEikonEnvmak->AllocReadResourceLC( R_QTN_MCE_MARKAS_READ );
                    TBufC<30> bufread(markasRead->Des());
                    HBufC* markasUnRead = ownEikonEnvmak->AllocReadResourceLC( R_QTN_MCE_MARKAS_UNREAD );
                    TBufC<30> bufUnread(markasUnRead->Des());
                    CleanupStack::PopAndDestroy(2); //markasUnRead, markasRead
                    if(functionInfo.iFuncId == KMtmUiFunctionMarkAsRead)
                        {
                        iMceListView->SetMarkReadUnread( ETrue );
                        }
                    aMenuPane.AddMenuItemL( data, aMenuCommandId );
                    }
                }
            }
        else
            {
            if ( MceViewActive( EMceMainViewActive ) && !CheckMTMFunctionL( functionInfo, selectedEntry ) )
                {
                aMenuPane.AddMenuItemL( data, aMenuCommandId );
                }
            }
        sendCmd++;
        }
    MCELOGGER_LEAVEFN("AddMTMFunctionsL()");
    }

// ----------------------------------------------------
// CMceUi::CheckMTMFunctionL
// ----------------------------------------------------
TInt CMceUi::CheckMTMFunctionL( const TMsgFunctionInfo& aFunction, TMsvEntry& aEntryToCheck )
    {
    TInt functionAvailable = KErrNotFound;

    CBaseMtmUiData* uiData = NULL;

    if ( MceViewActive( EMceMainViewActive ) )
        {
        if ( !( aFunction.iFlags & EMtudContextSpecific ) )
            {
            uiData = GetMtmUiDataL( aFunction.iMtmUid );
            if ( uiData )
                {
                functionAvailable = uiData->OperationSupportedL(aFunction.iFuncId, aEntryToCheck);
                }
            }
        }
    else
        {
        if ( aFunction.iMtmUid == aEntryToCheck.iMtm )
            {
            uiData = GetMtmUiDataL( aFunction.iMtmUid );
            }

        if ( aFunction.iFlags & EMtudContextSpecific )
            {
            if ( uiData )
                {
                functionAvailable =
                    uiData->OperationSupportedL(aFunction.iFuncId, aEntryToCheck);
                }
            }
        else if ( aFunction.iFlags & EMtudRemoteOnly )
            {
            if ( uiData &&
                 aEntryToCheck.iMtm != KUidMsvLocalServiceMtm )
                {
                functionAvailable =
                    uiData->OperationSupportedL(aFunction.iFuncId, aEntryToCheck);
                }
            }
        }

    return functionAvailable;
    }

// ----------------------------------------------------
// CMceUi::GetCurrentEntryL
// ----------------------------------------------------
TBool CMceUi::GetCurrentEntryL(TMsvEntry& aEntry, TBool aOpenedFolder /*= EFalse*/) const
    {
    MCELOGGER_ENTERFN("GetCurrentEntryL()");

    TMsvId cursorId = KErrNotFound;

    if ( MceViewActive( EMceMainViewActive ) )
        {
        cursorId = iMceMainView->ListContainer()->CurrentItemId();
        }
    else
        {
        if ( aOpenedFolder )
            {
            cursorId = iMceListView->ListContainer()->CurrentFolderId();
            }
        else
            {
            if ( iMceListView->ListContainer()->CurrentItemSelectionCount() == 1 )
                {
                CMsvEntrySelection* selection =
                    iMceListView->ListContainer()->CurrentItemSelectionL();
                cursorId = selection->At(0);
                delete selection;
                }
            else
                {
                cursorId = KErrNotFound;
                }
            }
        }

    if ( cursorId == KErrNotFound )
        {
        MCELOGGER_LEAVEFN("GetCurrentEntryL() selected entry not found");
        return EFalse;
        }

    TMsvId service;
    const TInt err = iSession->GetEntry(cursorId, service, aEntry);

    if ( err != KErrNone && err != KErrNotFound )
        {
        User::Leave( err );
        }

    MCELOGGER_LEAVEFN("GetCurrentEntryL()");
    return ( err == KErrNone );
    }

// ----------------------------------------------------
// CMceUi::CheckCommandAvailableL
// ----------------------------------------------------
TInt CMceUi::CheckCommandAvailableL( TInt aCommand, TMsvEntry& aEntryToCheck )
    {
    TInt rid = 0; // command is available

    const TBool remoteContext =
        aEntryToCheck.iServiceId != KMsvLocalServiceIndexEntryId;

    switch ( aCommand )
        {
        case EMceCmdUndelete:
            if ( remoteContext )
                {
                CBaseMtmUiData* uiData = GetMtmUiDataL( aEntryToCheck.iMtm );
                if ( !uiData || !uiData->CanUnDeleteFromEntryL(aEntryToCheck, rid) && !rid )
                    {
                    rid = KErrNotSupported;
                    }
                }
            break;

        case EMceCmdReply:
            {
            CBaseMtmUiData* uiData = GetMtmUiDataL( aEntryToCheck.iMtm );
            if ( !uiData || !uiData->CanReplyToEntryL(aEntryToCheck, rid) )
                {
                rid = KErrNotSupported;
                }
            else
                {
                if ( aEntryToCheck.iMtm == KSenduiMtmSmsUid || aEntryToCheck.iMtm == KSenduiMtmBioUid 
                     || aEntryToCheck.iMtm == KSenduiMtmMmsUid || aEntryToCheck.iMtm == KSenduiMMSNotificationUid )
                    {
                    if ( !MceUtils::ValidPhoneNumberL( aEntryToCheck.Id(), *iSession ) )
                        {
                        rid = KErrNotSupported;
                        }
                    }
                
                }
            }
            break;
         
        case EMceCmdForward:
            {
            CBaseMtmUiData* uiData = GetMtmUiDataL( aEntryToCheck.iMtm );
            if ( !uiData || !uiData->CanForwardEntryL( aEntryToCheck, rid ) )
                {
                rid = KErrNotSupported;
                }
            }
            break;   
            
        default:
            if (aCommand >= EMceCmdFirstMTMFunction)
                {
                rid = CheckMTMFunctionL(
                    iMTMFunctionsArray->At( aCommand-EMceCmdFirstMTMFunction ), aEntryToCheck );
                }
            else
                {
                rid = KErrNotSupported;
                }
            break;
        };

    return rid;
    }

// ----------------------------------------------------
// CMceUi::CheckCommandAvailableL
// ----------------------------------------------------
TInt CMceUi::CheckCommandAvailableL( TInt aCommand, CMsvEntrySelection* aEntriesToCheck )
    {
    __ASSERT_DEBUG( aEntriesToCheck, Panic( EMceUiErrArrayEmpty ) );
    TInt rid = 0; // command is available
    if ( !aEntriesToCheck || aEntriesToCheck->Count() == 0 )
        {
#if defined(_DEBUG)
        Panic(EMceUiErrArrayEmpty);
#endif
        return KErrNotSupported;
        }

    TMsvEntry entry;
    TMsvId serviceId;
    TMsvId id = (*aEntriesToCheck)[0];

    if ( iSession->GetEntry( id, serviceId, entry ) != KErrNone )
        {
        return KErrNotSupported;
        }

    if (aCommand >= EMceCmdFirstMTMFunction)
        {
        rid = KErrNotSupported;
        }
    else if ( aCommand == EMceCmdUndelete )
        {
        if ( entry.iServiceId != KMsvLocalServiceIndexEntryId )
            {
            CBaseMtmUiData* uiData = GetMtmUiDataL( entry.iMtm );
            TBool canUndelete = EFalse;
            if ( uiData )
                {
                const TInt count = aEntriesToCheck->Count();
                for ( TInt loop = 0; loop < count && !canUndelete; loop++ )
                    {
                    id = (*aEntriesToCheck)[loop];
                    if ( iSession->GetEntry( id, serviceId, entry ) == KErrNone &&
                         uiData->CanUnDeleteFromEntryL(entry, rid) )
                        {
                        canUndelete = ETrue;
                        }
                    }
                }
            rid = canUndelete;
            }
        else
            {
            rid = KErrNotSupported;
            }
        }

    return rid;
    }


// ----------------------------------------------------
// CMceUi::HandleMTMFunctionL
// ----------------------------------------------------
void CMceUi::HandleMTMFunctionL(const TMsgFunctionInfo& aFunction)
    {
    MCELOGGER_ENTERFN("HandleMTMFunctionL()");

    CMsvEntrySelection* sel = NULL;
    if ( MceViewActive( EMceMainViewActive ) )
        {
        sel = new ( ELeave ) CMsvEntrySelection();
        CleanupStack::PushL( sel );
        sel->AppendL( iMceMainView->ListContainer()->CurrentItemId() );
        }
    else
        {
        sel = iMceListView->ListContainer()->CurrentItemSelectionRefreshL();
        CleanupStack::PushL( sel );
        }


    TMsvId contextId = KMsvNullIndexEntryId;
    if ( aFunction.iFlags&EMtudContextSpecific )
        {
        if ( sel->Count() != 0 )
            {
            contextId = (*sel)[0];
            TMsvId service;
            TMsvEntry entry;
            if ( iSession->GetEntry( contextId, service, entry) != KErrNone ||
                entry.iMtm != aFunction.iMtmUid )
                {
                contextId = KMsvNullIndexEntryId;
                }
            }
        if ( contextId == KMsvNullIndexEntryId )
            {
            CleanupStack::PopAndDestroy( sel );
            return;
            }
        }

    CAknInputBlock::NewLC();

    CBaseMtmUi& mtmUi=iMtmStore->GetMtmUiLC(aFunction.iMtmUid);
    CBaseMtm&   mtm=mtmUi.BaseMtm();
    if (aFunction.iFlags&EMtudContextSpecific)
        {
        if (mtm.HasContext())
            {
            mtm.SwitchCurrentEntryL(contextId);
            }
        else
            {
            CMsvEntry* centry=iSession->GetEntryL(contextId);
            mtm.SetCurrentEntryL(centry);
            }
        }

    TBool tabsToCleanupStack = EFalse;

    if ( iMceUiFlags.MceFlag( EMceUiFlagsTabsActive )
        && aFunction.iFuncId != KMtmUiFunctionMessageInfo )
        {
        // must remove tabs because if no mailboxes created then
        // mailbox settings dialog is displayed and tabs should not be shown then.
        RemoveTabs();
        CleanupStack::PushL( TCleanupItem( ShowTabs, this ) );
        tabsToCleanupStack = ETrue;
        }

    TBuf8<1> buf;
    if (!(aFunction.iFlags&EMtudAsynchronous))
        {
        mtmUi.InvokeSyncFunctionL(aFunction.iFuncId, *sel, buf);
        }
    else
        {
        CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
        CleanupStack::PushL( singleOpWatcher );

        CMsvOperation* op=mtmUi.InvokeAsyncFunctionL( aFunction.iFuncId, *sel,
            singleOpWatcher->iStatus, buf );

        if ( op )
            {
            CleanupStack::PushL( op );
            iOperations.AppendL( singleOpWatcher );
            CleanupStack::Pop( 2 ); // singleOpWatcher, op
            singleOpWatcher->SetOperation( op );
            MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
            }
        else
            {
            CleanupStack::PopAndDestroy( singleOpWatcher );
            }
        }

    if ( tabsToCleanupStack )
        {
        CleanupStack::PopAndDestroy(); // TCleanupItem - will show tabs again
        }

    CleanupStack::PopAndDestroy(3, sel);// sel, CAknInputBlock, release mtmUi

    MCELOGGER_LEAVEFN("HandleMTMFunctionL()");
    }

// ----------------------------------------------------
// CMceUi::SetMceViewActive
// ----------------------------------------------------
void CMceUi::SetMceViewActive( TUint aActiveView )
    {
    iMceActiveView = aActiveView;
    if ( aActiveView & EMceDeliveryReportsViewActive )
        {
        iMceMainView->SetDeliveryReportsSelected();
        }
    }

// ----------------------------------------------------
// CMceUi::MceViewActive
// ----------------------------------------------------
TBool CMceUi::MceViewActive( TInt aActiveView ) const
    {
    return iMceActiveView & aActiveView;
    }

// ----------------------------------------------------
// CMceUi::MoveFromOutboxToDraftsL
// ----------------------------------------------------
void CMceUi::MoveFromOutboxToDraftsL()
    {
    MCELOGGER_ENTERFN("MoveFromOutboxToDraftsL()");
    __ASSERT_DEBUG( MceViewActive( EMceMessageViewActive ),
        Panic( EMceUiErrCannotMoveFromMainView ) );

    LeaveIfDiskSpaceUnderCriticalLevelL();

    CMsvEntrySelection* selection = iMceListView->ListContainer()
        ->CurrentItemSelectionL();
    CleanupStack::PushL( selection );


    if ( selection->Count() == 0 ||
         IsMessageSendingL( selection->At(0) ) )
        {
        CleanupStack::PopAndDestroy( selection );
        MCELOGGER_LEAVEFN("MoveFromOutboxToDraftsL1()");
        return;
        }

    CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
    CleanupStack::PushL( singleOpWatcher );
    CAknInputBlock::NewLC();

    CMsvProgressReporterOperation* op =
        CMsvProgressReporterOperation::NewL(
        *iSession, singleOpWatcher->iStatus, EMbmAvkonQgn_note_move );
    CleanupStack::PushL( op );

    CMsvOperation* subOp = CMceCancelSendingOperation::NewL(
         *iSession,
         op->RequestStatus(),
         selection->At(0),
         CMceCancelSendingOperation::ECancelAndMoveToDrafts,
         *iMtmStore );

    op->SetOperationL(subOp); // this takes ownership immediately, so no cleanupstack needed.

    HBufC* text = StringLoader::LoadLC(
        R_MUIU_LOCAL_PROGRESS_MOVING_1,
        iEikonEnv );
    op->SetTitleL( *text );
    CleanupStack::PopAndDestroy( text );
    CleanupStack::Pop( op );
    singleOpWatcher->SetOperation( op );
    CleanupStack::PopAndDestroy(); // CAknInputBlock
    CleanupStack::PushL( op );
    iOperations.AppendL( singleOpWatcher );
    CleanupStack::Pop(2, singleOpWatcher); // singleOpWatcher, op


    MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", op->Id() );
    iMceListView->ListContainer()->ClearSelection();
    CleanupStack::PopAndDestroy( selection ); 
    MCELOGGER_LEAVEFN("MoveFromOutboxToDraftsL2()");
    }

// ----------------------------------------------------
// CMceUi::ForceMtmLoaderFinish
// ----------------------------------------------------
void CMceUi::ForceMtmLoaderFinish()
    {
    MCELOGGER_ENTERFN("ForceMtmLoaderFinish()");
    if ( iMtmLoader )
        {
        TRAP_IGNORE(iMtmLoader->FinishL(iAudioMsgEnabled, iPostcardEnabled)); // CR : 401-1806
        delete iMtmLoader;
        iMtmLoader = NULL;
        }
    MCELOGGER_LEAVEFN("ForceMtmLoaderFinish()");
    }

// ----------------------------------------------------
// CMceUi::GoOfflineSynchronouslyL
// ----------------------------------------------------
void CMceUi::GoOfflineSynchronouslyL( TMsvId aAccount )
    {
    MCELOGGER_ENTERFN("GoOfflineSynchronouslyL()");
    TMsvEntry tentry;
    (void)GetEntryL(aAccount, tentry);

    if (  iAlwaysOnline && ( tentry.iMtm == KSenduiMtmImap4Uid
        || tentry.iMtm == KSenduiMtmPop3Uid ) )
        {
        if ( !ServiceIdFound( tentry.Id()) )
            {
            // do not close always online connection
            return;
            }
        }

    CBaseMtmUi& ui=iMtmStore->GetMtmUiAndSetContextLC(tentry);
    CAknInputBlock::NewLC();

    CMuiuOperationWait* wait =
        CMuiuOperationWait::NewLC(EActivePriorityWsEvents+10);
    CMsvOperation* op=ui.CloseL(wait->iStatus);
    wait->Start();
    CleanupStack::PopAndDestroy( wait );
    delete op;
    CleanupStack::PopAndDestroy( 2 ); // CAknInputBlock, release mtmui
    MCELOGGER_LEAVEFN("GoOfflineSynchronouslyL()");
    }

// ----------------------------------------------------
// CMceUi::IsEditorOpen
// ----------------------------------------------------
TBool CMceUi::IsEditorOpen( ) const
    {
    return ( iEditorOperation ? ETrue : EFalse );
    }

// ----------------------------------------------------
// CMceUi::LeaveIfDiskSpaceUnderCriticalLevelL
// Static function.
// Used in CreateNewMessageL as TCleanupItem.
// ----------------------------------------------------
void CMceUi::LeaveIfDiskSpaceUnderCriticalLevelL( TInt aBytesToWrite )
    {
    MCELOGGER_WRITE_FORMAT("LeaveIfDiskSpaceUnderCriticalLevelL: %d", aBytesToWrite );


    if ( iMceUiFlags.MceFlag( EMceUiFlagsMediaUnavailable ) )
        {
        MCELOGGER_WRITE("LeaveIfDiskSpaceUnderCriticalLevelL: media unavailable, leave");
        User::Leave( KMsvIndexBackup );
        }

    if ( MsvUiServiceUtilities::DiskSpaceBelowCriticalLevelL(*iSession, aBytesToWrite) )
        {
        User::Leave( KErrDiskFull );
        }
    MCELOGGER_WRITE("LeaveIfDiskSpaceUnderCriticalLevelL: OK to proceed");
    }

// ----------------------------------------------------
// CMceUi::CancelFreeDiskSpaceRequest
// Static function.
// Used in CreateNewMessageL as TCleanupItem.
// ----------------------------------------------------
void CMceUi::CancelFreeDiskSpaceRequest(TAny* /*aAny*/)
    {
    MCELOGGER_ENTERFN("CancelFreeDiskSpaceRequest()");

// Cancel the free disk space request to be added

    MCELOGGER_LEAVEFN("CancelFreeDiskSpaceRequest()");
    }

// ----------------------------------------------------
// CMceUi::TitlePaneL
// Returns mce ui's title pane
// ----------------------------------------------------
CAknTitlePane* CMceUi::TitlePaneL() const
    {
    return (CAknTitlePane *)(iEikonEnv->AppUiFactory(*this))->StatusPane()->ControlL(
        TUid::Uid(EEikStatusPaneUidTitle));
    }

// ----------------------------------------------------
// CMceUi::IsMessageSendingL
//
// ----------------------------------------------------
TBool CMceUi::IsMessageSendingL( TMsvId aEntryId ) const
    {
    MCELOGGER_ENTERFN("IsMessageSendingL()");
    MCELOGGER_WRITE_FORMAT( "Check entry 0x%x", aEntryId );

    TBool sending = EFalse;
    iEntry->SetEntryL( aEntryId );
    const TMsvEntry& entry = iEntry->Entry();
    if ( entry.Parent() == KMsvGlobalOutBoxIndexEntryId &&
         entry.SendingState() == KMsvSendStateSending &&
         ( entry.iMtm == KSenduiMtmSmsUid ||
         entry.iMtm == KSenduiMtmMmsUid )
       )
        {
                sending = ETrue;
        }
    MCELOGGER_WRITE_FORMAT( "Entry sending: %d", sending);
    MCELOGGER_LEAVEFN("IsMessageSendingL()");
    return sending;
    }

// ----------------------------------------------------
// CMceUi::ActivateConnectionQueryTimerL
//
// ----------------------------------------------------
void CMceUi::ActivateConnectionQueryTimerL( TMsvId aEntryId )
    {
    MCELOGGER_ENTERFN("ActivateConnectionQueryTimerL()");
    if ( !iConnectMailboxTimer )
        {
        iConnectMailboxTimer = CMceConnectMailboxTimer::NewL( *this );
        }

    TMsvEntry tentry;
    TMsvId serviceId = GetEntryL( aEntryId, tentry );
    if ( tentry.iMtm != KSenduiMtmImap4Uid &&
         tentry.iMtm != KSenduiMtmPop3Uid )
        {
        // not mailbox, do nothing.
        return;
        }

    if ( serviceId != aEntryId )
        {
        // lets find out that service...
        GetEntryL( serviceId, tentry );
        }
    if ( !tentry.Connected() )
        {
        // this cancels possible old timer
        iConnectMailboxTimer->SetTimer( serviceId );
        }
    MCELOGGER_LEAVEFN("ActivateConnectionQueryTimerL()");
    }

// ----------------------------------------------------
// CMceUi::ReplyL
//
// ----------------------------------------------------
void CMceUi::ReplyL(TInt /*aReplyCommand*/)
    {
    MCELOGGER_ENTERFN("ReplyL()");
    LeaveIfDiskSpaceUnderCriticalLevelL( iDiskSpaceForMoveOrCopy );

    if ( MceViewActive( EMceMainViewActive ) )
        {
        return;
        }

    CMsvEntrySelection * selection = iMceListView->ListContainer()->CurrentItemSelectionL();
    CleanupStack::PushL( selection );
    if ( selection->Count() <= 0)
        {
        CleanupStack::PopAndDestroy( selection );
        return;
        }

    TMsvEntry entry;
    TMsvId serviceId;
    User::LeaveIfError( iSession->GetEntry(selection->At(0),serviceId,entry) ); // original message?

    // NCN reset, received mail has been replied before opening it
    if ( ((entry.iMtm == KSenduiMtmImap4Uid)
        || (entry.iMtm == KSenduiMtmPop3Uid)
        || (entry.iMtm == KSenduiMtmSyncMLEmailUid)
        || CheckTechnologyTypeFromMtm( KMailTechnologyTypeUid, entry.iMtm ))
        && entry.Unread() )
        {
        
        HandleNotif(iMceListView->ListContainer()->FolderEntry().iServiceId);

        }

    CleanupStack::PopAndDestroy( selection ); 

    TMsvPartList parts=KMsvMessagePartBody|KMsvMessagePartOriginator|KMsvMessagePartDescription;

    // Mark local entry as read before replying, remote entries should be handled by mtm ui
    if ( entry.Unread() && entry.iServiceId == KMsvLocalServiceIndexEntryId )
        {
        iEntry->SetEntryL( entry.Id() );
        TMsvEntry entry = iEntry->Entry();
        entry.SetUnread( EFalse );
        iEntry->ChangeL( entry );
        }

    if ( entry.iBioType == KMsgBioUidPictureMsg.iUid)
        {
        //picture message
        TMsvId origMsgId = entry.Id();

        // Change the MTM type of msg temporarily

        CMsvEntry* cEntry = iSession->GetEntryL( origMsgId );
        CleanupStack::PushL( cEntry );
        TMsvEntry tentry( cEntry->Entry() );
        const TUid origMtmUid = tentry.iMtm;
        tentry.iMtm = KSenduiMtmSmsUid;

        // Create registry instances
        CClientMtmRegistry* mtmReg = CClientMtmRegistry::NewL( *iSession );
        CleanupStack::PushL(mtmReg);
        CMtmUiRegistry* mtmUiReg = CMtmUiRegistry::NewL( *iSession );
        CleanupStack::PushL(mtmUiReg);

        // Create the SMS MTM
        CBaseMtm* mtm = mtmReg->NewMtmL( KSenduiMtmSmsUid );
        CleanupStack::PushL(mtm);
        CBaseMtmUi* mtmUi = mtmUiReg->NewMtmUiL( *mtm );
        CleanupStack::PushL(mtmUi);

        // Trap errors, so we can try to restore the original MTM Uid

        TRAPD(err,
            {

            cEntry->ChangeL( tentry );

            // Set its context
            mtm->SwitchCurrentEntryL( origMsgId );

            mtmUi->SetPreferences( mtmUi->Preferences() | EMtmUiFlagEditorPreferEmbedded );
            CAknInputBlock::NewLC();

            CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
            CleanupStack::PushL( singleOpWatcher );

            CMsvOperation* oper = mtmUi->ReplyL(
                KMsvDraftEntryIdValue, parts, singleOpWatcher->iStatus );

            CleanupStack::PushL( oper );
            iOperations.AppendL( singleOpWatcher );
            CleanupStack::Pop( 2, singleOpWatcher ); // oper
            singleOpWatcher->SetOperation( oper );
            CleanupStack::PopAndDestroy(  ); // CAknInputBlock

            });

        // Restore original Mtm Uid
        tentry = cEntry->Entry();
        tentry.iMtm = origMtmUid;
        cEntry->ChangeL(tentry);
        mtm->SwitchCurrentEntryL( origMsgId );

        User::LeaveIfError(err);
        CleanupStack::PopAndDestroy( 5 ); // mtmUi, mtmReg, mtmUiReg, mtm, cEntry
        }

    else
        {
        CBaseMtmUi& ui = iMtmStore->GetMtmUiAndSetContextLC( entry );
        ui.SetPreferences( ui.Preferences() | EMtmUiFlagEditorPreferEmbedded );
        CAknInputBlock::NewLC();
        CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
        CleanupStack::PushL( singleOpWatcher );

        CMsvOperation* oper = ui.ReplyL(
            KMsvDraftEntryIdValue, parts, singleOpWatcher->iStatus );

        CleanupStack::PushL( oper );
        iOperations.AppendL( singleOpWatcher );
        CleanupStack::Pop( 2, singleOpWatcher ); // oper
        singleOpWatcher->SetOperation( oper );
        MCELOGGER_WRITE_FORMAT("iOperations.AppendL(%d)", oper->Id() );
        CleanupStack::PopAndDestroy( 2 ); // CAknInputBlock, ui
        }
    MCELOGGER_LEAVEFN("ReplyL()");

    }

// ----------------------------------------------------
// CMceUi::MarkAsReadL
// ----------------------------------------------------
void CMceUi::MarkAsReadL( TBool aRead )
    {
    MCELOGGER_ENTERFN("MarkAsReadL()");
    CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
    CleanupStack::PushL(singleOpWatcher);

    CMsvEntrySelection* sel = iMceListView->ListContainer()
        ->CurrentItemSelectionL();
    CleanupStack::PushL( sel );
    TInt selCount = sel->Count();
    if ( selCount <= 0 )
        {
        CleanupStack::PopAndDestroy( 2 ); // singleOpWatcher, sel
        return;
        }

    TMsvId serviceId;
    TMsvEntry entry;
    User::LeaveIfError( iSession->GetEntry( sel->At(0), serviceId, entry ) );
    CBaseMtmUi& mtmUi = iMtmStore->GetMtmUiLC( entry.iMtm );
    mtmUi.SetPreferences( mtmUi.Preferences() | EMtmUiFlagEditorPreferEmbedded );
    CleanupStack::PopAndDestroy( ); // mtmUi

    CMsvProgressReporterOperation* op =
        CMsvProgressReporterOperation::NewL(
            *iSession, singleOpWatcher->iStatus );
    CleanupStack::PushL( op );
    HBufC* text = StringLoader::LoadLC( R_MCE_MARK_AS_READ_PROGRESS, iEikonEnv );
    op->SetTitleL( *text );
    CleanupStack::PopAndDestroy( text );

    // Determine the action for unread flag
    TInt type =
            aRead ? CMceRemoveNewFlag::EMceRemoveEntryFlagUnread :
                    CMceRemoveNewFlag::EMceRemoveEntryFlagNew;
    CMceRemoveNewFlag* subOp = CMceRemoveNewFlag::NewL(
    type, *iSession, op->RequestStatus(), sel );

    op->SetOperationL( subOp ); // this takes ownership immediately, so no cleanupstack needed.
    if ( selCount ==  1 )
        {
        op->MakeProgressVisibleL(EFalse);
        }
    op->SetProgressDecoder( *subOp );
    CleanupStack::Pop( op );

    iOperations.AppendL( singleOpWatcher );
    CleanupStack::Pop( 2, singleOpWatcher ); // singleOpWatcher, sel
    singleOpWatcher->SetOperation( op );
    iMceListView->ListContainer()->ClearSelection();
    if ( CheckTechnologyTypeFromMtm( KMailTechnologyTypeUid, entry.iMtm )&& aRead )
        {
        HandleNotif(iMceListView->ListContainer()->FolderEntry().iServiceId);
        }
    MCELOGGER_WRITE_FORMAT( "iOperations.AppendL(%d)", op->Id() );
    MCELOGGER_LEAVEFN("MarkAsReadL()");
    }

// ----------------------------------------------------
// CMceUi::TabChangedL
//
// ----------------------------------------------------
void CMceUi::TabChangedL(TInt aIndex)
    {
    TBool bOBoxOrMBox = EFalse ;
    if ( !MceViewActive( EMceMessageViewActive )
        && !MceViewActive( EMceDeliveryReportsViewActive ) )
        {
        return;
        }
    TInt count = iTabsArray->Count();
    TMsvId newId = KMsvGlobalInBoxIndexEntryId;
    if ( aIndex < count )
        {
        newId = (*iTabsArray)[aIndex];
        }

    CancelMailboxTimer();

    if ( MceViewActive( EMceDeliveryReportsViewActive ) )
        {
        OpenFolderViewL( newId );
        }
    else if ( !MceViewActive( EMceDeliveryReportsViewActive )
            && newId == KMceDeliveryReportsListIdValue )
        {
        // activate delivery reports view
        ActivateLocalViewL( KMceDeliveryReportViewId );
        }
    else
        {
        TBool bIsFromMailbox = EFalse ;
        TBool bIsToMailbox = EFalse ;
        TUid mtm = iMceListView->ListContainer()->FolderEntry().iMtm ;
        bIsFromMailbox = CheckTechnologyTypeFromMtm( KMailTechnologyTypeUid, mtm );
        
        TMsvEntry currentEntry;
        TMsvId serviceId; // not used here but needed by GetEntry function
        if ( iSession->GetEntry( newId, serviceId, currentEntry )
        	== KErrNone )
	        {
	        bIsToMailbox = CheckTechnologyTypeFromMtm( KMailTechnologyTypeUid, currentEntry.iMtm ); 	
	        }
        
        TMsvId oldId = iMceListView->ListContainer()->FolderEntry().Id();
        if (oldId == KMsvGlobalOutBoxIndexEntryId || newId == KMsvGlobalOutBoxIndexEntryId
            || bIsFromMailbox || bIsToMailbox)
	        {
		        if (bIsFromMailbox || bIsToMailbox || 
		            oldId == KMsvGlobalOutBoxIndexEntryId || iMceListView->ListContainer()->MceListId() != EMceListTypeTwoRow)
		        {
		        bOBoxOrMBox = ETrue ;
		        iLocalScreenClearer = CAknLocalScreenClearer::NewL( EFalse );	
		        }
	        }
        iMceListView->ChangeFolderAndRefreshListboxL( newId );
        }
     
     if (bOBoxOrMBox)
	     {
	     delete iLocalScreenClearer;
	     iLocalScreenClearer = NULL;
	     }
    }

// ----------------------------------------------------
// CMceUi::IsPresent
// ----------------------------------------------------
TBool CMceUi::IsPresent( TUid aMtm ) const
    {
    return iUiRegistry->IsPresent( aMtm );
    }

// ----------------------------------------------------
// CMceUi::ClearExitAfterDisconnectFlag
//
// ----------------------------------------------------
void CMceUi::ClearExitAfterDisconnectFlag( )
    {
    iMceUiFlags.ClearMceFlag( EMceUiFlagsExitAfterDisconnect  );
    }

// ----------------------------------------------------
// CMceUi::SetDontExitOnNextOperationComplete
//
// ----------------------------------------------------
void CMceUi::SetDontExitOnNextOperationComplete( )
    {
    MCELOGGER_WRITE("CMceUi::SetDontExitOnNextOperationComplete");
    iMceUiFlags.SetMceFlag( EMceUiFlagsDoNotExitAfterNextOperationComplete );
    if ( iCancelExitFlagOperation && !( iCancelExitFlagOperation->IsActive() ) )
        {
        iCancelExitFlagOperation->Start( 
            TCallBack( ClearDontExitOnNextOperationComplete, this ) );
        }
    }

// ----------------------------------------------------
// CMceUi::ClearDontExitOnNextOperationComplete
//
// ----------------------------------------------------
void CMceUi::ClearDontExitOnNextOperationComplete( )
    {
    MCELOGGER_WRITE("CMceUi::ClearDontExitOnNextOperationComplete");
    iMceUiFlags.ClearMceFlag( EMceUiFlagsDoNotExitAfterNextOperationComplete );
    }

// ----------------------------------------------------
// CMceUi::ClearDontExitOnNextOperationComplete
//
// ----------------------------------------------------
TInt CMceUi::ClearDontExitOnNextOperationComplete( TAny* aSelf )
    {
    reinterpret_cast<CMceUi*>(aSelf)->ClearDontExitOnNextOperationComplete();
    return KErrNone;
    }

// ----------------------------------------------------
// CMceUi::SyncMlNewMessageItemL
// ----------------------------------------------------
void CMceUi::SyncMlNewMessageItemL( const CMsvEntrySelection* aSelection, TInt aEvent )
    {
    TMsvId serviceId;
    TMsvEntry entry;
    if ( aEvent == EMsvEntriesCreated )
        {
        if ( iSession->GetEntry( aSelection->At(0), serviceId, entry ) == KErrNone )
            {
            if ( entry.iMtm == KSenduiMtmSyncMLEmailUid )
                {
                HandleMTMChangeL();
                }
            }
        }
    else
        {
        if ( aEvent == EMsvEntriesDeleted )
            {
            CMsvEntrySelection* sel=iRootEntry->ChildrenWithTypeL( KUidMsvServiceEntry );
            CleanupStack::PushL( sel );
            const TMsvEntry* tentry=NULL;
            TInt syncMl = 0;
            for ( TInt cc=sel->Count(); --cc>=0 && !syncMl; )
                {
                tentry=&(iRootEntry->ChildDataL((*sel)[cc]));
                if ( tentry->iMtm == KSenduiMtmSyncMLEmailUid )
                    {
                    syncMl++;
                    }
                }
            if ( !syncMl )
                {
                HandleMTMChangeL();
                }

            CleanupStack::PopAndDestroy( sel );
            }
        }
    }

// ----------------------------------------------------
// CMceUi::SyncMlMoveFromOutboxToDraftsL
// ----------------------------------------------------
void CMceUi::SyncMlMoveFromOutboxToDraftsL( )
    {
    LeaveIfDiskSpaceUnderCriticalLevelL( iDiskSpaceForMoveOrCopy );

    __ASSERT_DEBUG( MceViewActive( EMceMessageViewActive ),
        Panic( EMceUiErrCannotMoveFromMainView ) );
    if ( MceViewActive( EMceMainViewActive ) )
        {
        return;
        }

    const TMsvId sourceId = iMceListView->ListContainer()->CurrentFolderId();
    TMsvEntry srcEntry;
    GetEntryL( sourceId, srcEntry );

    CMsvEntrySelection * selection = iMceListView->ListContainer()
        ->CurrentItemSelectionL();
    CleanupStack::PushL( selection );

    if (  selection->Count() <= 0 )
        {
        CleanupStack::PopAndDestroy( selection );
        return;
        }

    CMsvOperation* op=NULL;

    CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
    CleanupStack::PushL( singleOpWatcher );

    CAknInputBlock::NewLC();

    CBaseMtmUi& ui=iMtmStore->GetMtmUiAndSetContextLC( srcEntry );
    op=ui.MoveFromL( *selection, KMsvDraftEntryId, singleOpWatcher->iStatus );
    CleanupStack::PopAndDestroy(); // release ui

    CleanupStack::PopAndDestroy(); // CAknInputBlock::NewLC()
    CleanupStack::PushL(op);
    iOperations.AppendL( singleOpWatcher );
    CleanupStack::Pop( 2 ); // singleOpWatcher, op
    singleOpWatcher->SetOperation( op );

    iMceListView->ListContainer()->ClearSelection();
    CleanupStack::PopAndDestroy( selection ); 
    }

// ----------------------------------------------------
// CMceUi::MtmName
//
// ----------------------------------------------------
THumanReadableName CMceUi::MtmName( TUid aMtm ) const
    {
    THumanReadableName data;
    const TInt count = iMsgTypesSettings.Count();
    for ( TInt cc = 0; cc < count; cc++ )
        {
        TUidNameInfo info = iMsgTypesSettings.At(cc);
        if ( info.iUid == aMtm )
            {
            data = info.iName;
            }
        }
    return data;
    }

// ----------------------------------------------------
// CMceUi::SetChangeMessageStore
//
// ----------------------------------------------------
void CMceUi::SetChangeMessageStore( TBool aChangeEnded )
    {
    if ( aChangeEnded )
        {
        iMceUiFlags.SetMceFlag( EMceUiFlagsExitOnMsvMediaAvailableEvent );
        }
    else
        {
        iMceUiFlags.ClearMceFlag( EMceUiFlagsExitOnMsvMediaAvailableEvent );
        }
    }


// ----------------------------------------------------
// CMceUi::IsSyncronizingL
//
// ----------------------------------------------------
TBool CMceUi::IsSyncronizingL( const TMsvEntry& entry )
    {
    TBool isSyncronizing = EFalse;

    if ( IsPresent( KSenduiMtmSyncMLEmailUid ) &&
            entry.iMtm == KSenduiMtmSyncMLEmailUid )
        {
        CBaseMtmUiData* uiData= GetMtmUiDataL( KSenduiMtmSyncMLEmailUid );
        if ( uiData )
            {
            TInt reason = 0;
            TBool syncronizing = uiData->CanOpenEntryL( entry, reason );
            if ( !syncronizing )
                {
                //cannot open during syncronizing
                HBufC* text = StringLoader::LoadLC( reason, iEikonEnv );
                CAknInformationNote* note = new (ELeave) CAknInformationNote();
                note->ExecuteLD(*text);
                CleanupStack::PopAndDestroy(); //text
                isSyncronizing = ETrue;
                }
            }
        }

    return isSyncronizing;
    }

// ----------------------------------------------------
// CMceUi::AlwaysOnlineLastConnectionL
//
// ----------------------------------------------------
TBool CMceUi::AlwaysOnlineLastConnectionL( const TMsvId aAccount )
    {
    TBool connectionMade = ETrue;

    CImumInSettingsData* settings =
        iEmailApi->MailboxServicesL().LoadMailboxSettingsL( aAccount );
    CleanupStack::PushL( settings );

    if ( iMceMainView->ListContainer()->ListItems()->
        AlwaysOnlineAccountL( aAccount, *settings ) )
        {
        TInt lastUpdateFailed = 0;
        settings->GetAttr(
            TImumInSettings::EKeyInfoLastUpdateFailed, lastUpdateFailed );
        if ( lastUpdateFailed )
            {
            TInt64 lastTime = 0;
            settings->GetAttr(
                TImumInSettings::EKeyInfoLastSuccessfulUpdate, lastTime );
            TTime settingsTime( lastTime );
            TBuf<KMceMaxDateString> time;
            TBuf<KMceMaxDateString> dateTime;

            HBufC* timeFormat = iCoeEnv->
                AllocReadResourceLC( R_QTN_TIME_USUAL_WITH_ZERO );
            HBufC* dateFormat = iCoeEnv->
                AllocReadResourceLC( R_QTN_DATE_USUAL_WITH_ZERO );

            TTime currentTime;
            currentTime.HomeTime();
            TDateTime currentDate( currentTime.DateTime() ); //current date
            TDateTime currentDateSettings( settingsTime.DateTime() ); //settings date

            TBool connBeforeToday = EFalse;
            if ( currentDate.Year() > currentDateSettings.Year() )
                {
                connBeforeToday = ETrue;
                }
            else
                if ( currentDate.Month() > currentDateSettings.Month() )
                    {
                    connBeforeToday = ETrue;
                    }
            else
                if ( currentDate.Day() > currentDateSettings.Day() )
                    {
                    connBeforeToday = ETrue;
                    }

            settingsTime.FormatL( time, *timeFormat );
            AknTextUtils::LanguageSpecificNumberConversion( time );

            settingsTime.FormatL( dateTime, *dateFormat );
            AknTextUtils::LanguageSpecificNumberConversion( dateTime );
            CleanupStack::PopAndDestroy( 2, timeFormat ); // timeFormat, dateFormat

            CAknQueryDialog* confDialog = CAknQueryDialog::NewL();
            HBufC* text = NULL;
            if ( connBeforeToday ) //last connection failed before today
                {
                CDesCArrayFlat* string=new(ELeave)CDesCArrayFlat( KMceArrayGranularity );
                CleanupStack::PushL( string );
                string->AppendL( dateTime );
                string->AppendL( time );
                text = StringLoader::LoadLC(
                    R_MCE_SETTINGS_ALWAYS_LASTTIME2, *string, iEikonEnv );
                }
            else
                {
                text = StringLoader::LoadLC(
                    R_MCE_SETTINGS_ALWAYS_LASTTIME, time, iEikonEnv );
                }

            confDialog->SetPromptL( *text );
            CleanupStack::PopAndDestroy( text );
            if ( connBeforeToday ) //last connection failed before today
                {
                CleanupStack::PopAndDestroy(); 
                }

            connectionMade = EFalse;

            if ( confDialog->ExecuteLD( R_MCE_CONFIRMATION ) )
                {
                GoOnlineL( aAccount );
                }

            }
        }

    CleanupStack::PopAndDestroy( 1 ); // extendedMailSettings
    return connectionMade;
    }

// ----------------------------------------------------
// CMceUi::AddOperationIdL
//
// ----------------------------------------------------
void CMceUi::AddOperationIdL( const TMsvOp& aOp, const TMsvId& aServiceId )
    {
    if ( !iMailAccountItemArray )
        {
        return;
        }

    TInt count = iMailAccountItemArray->Count();
    TInt found = EFalse;
    for ( TInt cc = 0; cc < count && !found; cc++ )
        {
        const TMceMailAccountItem& item = ((*iMailAccountItemArray)[cc]);
        if ( item.iServiceId == aServiceId )
            {
            ((*iMailAccountItemArray)[cc]).iMceConnection = ETrue;
            ((*iMailAccountItemArray)[cc]).iOp = aOp;
            found = ETrue;
            }
        }
    if ( !found )
        {
        TMceMailAccountItem item;
        item.iServiceId = aServiceId;
        item.iMceConnection = ETrue;
        item.iOp = aOp;
        iMailAccountItemArray->AppendL( item );
        }
    }

// ----------------------------------------------------
// CMceUi::RemoveOperationId
//
// ----------------------------------------------------
void CMceUi::RemoveOperationId( const TMsvId& /*aOpId*/, const TMsvId& aServiceId )
    {
    if ( !iMailAccountItemArray )
        {
        return;
        }

    TInt count = iMailAccountItemArray->Count();

    for ( TInt loop=count-1; loop>=0; loop-- )
        {
        TMceMailAccountItem item = ((*iMailAccountItemArray)[loop]);
        if ( item.iServiceId == aServiceId )
            {
            iMailAccountItemArray->Delete( loop );
            break;
            }
        }
    }

// ----------------------------------------------------
// CMceUi::ServiceIdFound
//
// ----------------------------------------------------
TBool CMceUi::ServiceIdFound( const TMsvId& aServiceId )
    {
    TInt found = EFalse;

    TInt count = iMailAccountItemArray->Count();

    for ( TInt cc = 0; cc < count && !found; cc++ )
        {
        TMceMailAccountItem item = ((*iMailAccountItemArray)[cc]);
        if ( item.iServiceId == aServiceId && item.iMceConnection  )
            {
            found = ETrue;
            }
        }
    return found;
    }

// ----------------------------------------------------
// CMceUi::AlwaysOnline
//
// ----------------------------------------------------
TBool CMceUi::AlwaysOnline( )
    {    
    return iAlwaysOnline;
    }

// ----------------------------------------------------
// CMceUi::IsMessageSetToBeDeletedFromServer
//
// ----------------------------------------------------
TBool CMceUi::IsMailSetToBeDeletedFromServerL( TMsvId aItemId )
    {
    TInt rid = 0;
    TBool ret = EFalse;
    TMsvId serviceId;
    TMsvEntry currentEntry;

    iSession->GetEntry( aItemId, serviceId, currentEntry );

    CBaseMtmUiData* mtmUiData = GetMtmUiDataL( currentEntry.iMtm );

    if ( mtmUiData && mtmUiData->CanUnDeleteFromEntryL( currentEntry, rid ) )
        {
        ret = ETrue;
        }

    return ret;
    }

// ----------------------------------------------------
// CMceUi::AnchoredItem
//
// ----------------------------------------------------
//
void CMceUi::DefineAnchorIdL( const CMsvEntrySelection* /*aSelection*/ )
    {
#if 0    
    if ( IsMailSetToBeDeletedFromServerL() )
        {
        SetAnchorId( iMceListView->ListContainer()->CurrentItemId() );
        return;
        }
    // TODO
    TInt currentItem = iMceListView->ListContainer()->CurrentItemIndex();
    CMceMessageListItemArray* items = iMceListView->ListContainer()->ListItems();
    iAnchorId = NULL;
    
// Do not change the focus if mailbox is offline and currently selected item is set to be deleted from server
    if ( IsMailSetToBeDeletedFromServerL() )
        {
        SetAnchorId( iMceListView->ListContainer()->CurrentItemId() );
        return;
        }
    
    for ( TInt i = currentItem; i < items->MdcaCount(); i++ ) // Find forwards
        {
        if ( aSelection->Find( items->ItemId( i ) ) == KErrNotFound )
            {
            SetAnchorId( items->ItemId( i ) );
            break;
            }
        }

    if ( !iAnchorId ) // If not found in forward search, find backwards
        {
        for ( TInt i = currentItem; i >= 0; i-- )
            {
            if ( aSelection->Find( items->ItemId( i ) ) == KErrNotFound )
                {
                SetAnchorId( items->ItemId( i ) );
                break;
                }
            }
        }
#endif        
    }

// ----------------------------------------------------
// CMceUi::AnchoredItem
//
// ----------------------------------------------------
TMsvId CMceUi::AnchoredItem()
    {
    return iAnchorId;
    }

// ----------------------------------------------------
// CMceUi::SetAnchorId
//
// ----------------------------------------------------
void CMceUi::SetAnchorId( TMsvId aAnchorId )
    {
    iAnchorId = aAnchorId;
    }

// ----------------------------------------------------
// CMceUi::EventL
//
// ----------------------------------------------------
void CMceUi::EventL( const CConnMonEventBase &aConnMonEvent )
    {
    switch ( aConnMonEvent.EventType() )
        {
        case EConnMonNetworkRegistrationChange:
            {
            CConnMonNetworkRegistrationChange* event =
                ( CConnMonNetworkRegistrationChange* ) &aConnMonEvent;                
            
            if ( iMceMainView->ListContainer() ) // Cannot set roaming if ListContainer is empty
                {
                CMceMainViewListItemArray* array = iMceMainView->ListContainer()->ListItems();
                if ( array && (array->Count() > 0) ) // List item array should not be empty
                    {
                    // Set roaming status
                    array->SetRoaming( event->RegistrationStatus() == ENetworkRegistrationRoaming );
                    
                    if ( MceViewActive( EMceMainViewActive ) )
                        {
                        //update icon only if main view is open
                        iMceMainView->ListContainer()->DrawDeferred();
                        }
                    }
                }
            }
            break;

        default:
            break;
        }
    }
// ----------------------------------------------------
// CMceUi::HandleGainingForeground
//
// ----------------------------------------------------
void CMceUi::HandleGainingForeground() // CR : 401-1806
    {
    if ( !iFeatureMgrEnabled )
        {
  	    TRAP_IGNORE( FeatureManager::InitializeLibL() );
  	    iFeatureMgrEnabled = ETrue ;
        }
  	TBool newPostcardVal = EFalse;
    TBool newAudioMsgVal = EFalse;
    newAudioMsgVal = FeatureManager::FeatureSupported( KFeatureIdAudioMessaging );
    newPostcardVal = FeatureManager::FeatureSupported( KFeatureIdMmsPostcard );
    if ( newAudioMsgVal != iAudioMsgEnabled || newPostcardVal != iPostcardEnabled )
        {
        TRAP_IGNORE( HandleMTMChangeL() );
        }
    if ( MceViewActive( EMceMainViewActive ) )
        {
        CheckIAUpdate();
        }
    }

// ----------------------------------------------------
// CMceUi::HandleLosingForeground
//
// ----------------------------------------------------
void CMceUi::HandleLosingForeground() // CR : 401-1806
    {
    iAudioMsgEnabled = FeatureManager::FeatureSupported( KFeatureIdAudioMessaging );
    iPostcardEnabled = FeatureManager::FeatureSupported( KFeatureIdMmsPostcard ) ;
    if ( iFeatureMgrEnabled ) 
        {
  	    FeatureManager::UnInitializeLib() ;
  	    iFeatureMgrEnabled = EFalse ;
  	    }
  	}
    
// ----------------------------------------------------
// CMceUi::ToPhoneMemoryQueryL
//
// ----------------------------------------------------
void CMceUi::ToPhoneMemoryQueryL( TBool aShowQuery )
    {

    if ( iPhoneMemoryQuery )
        {
        // If the dialog for whitching the message store is allready visible,
        // dismiss it
        delete iPhoneMemoryQuery;
        iPhoneMemoryQuery = NULL;
        return;
        }

    //this method is run when message centre is started
    if ( iMemoryInUse && !iMessageStoreExist && aShowQuery )
        {
        // check, if message store was in MMC but message server has
        // automatically changed message store to phone memory
        RFs& fs=iEikonEnv->FsSession();
        iMessageStoreExist = ETrue;
        TInt currentDrive = EDriveC;
        currentDrive = TInt(iSession->CurrentDriveL());

        TInt i = EDriveC;

        CRepository* repository = NULL;
        TRAPD( ret, repository = CRepository::NewL(KCRUidMuiuSettings) );

        if ( ret == KErrNone )
            {
            CleanupStack::PushL( repository );
            if ( repository->Get(KMuiuMemoryInUse,i) != KErrNone )
                {
                i = EDriveC;
                }
            if ( i != EDriveC && currentDrive == EDriveC )
                {
                // message server has changed the store automatically
                iMessageStoreExist = EFalse;
                }
            }

        if ( !iMessageStoreExist )
            {
            // message store was in MMC, but now there is no MMC
            iPhoneMemoryQuery = CAknQueryDialog::NewL();
            iPhoneMemoryQuery->ExecuteLD( R_MCE_MEMC_NOTE );
            iPhoneMemoryQuery = NULL; // ExecuteLD deletes the object
            }
        iMessageStoreExist = ETrue;

        if ( ret == KErrNone )
            {
            ret = repository->Set( KMuiuMemoryInUse, currentDrive );
            __ASSERT_DEBUG( !ret, User::Panic(KPanicText,KCRepositorySettingFailure) );
            CleanupStack::PopAndDestroy( repository );
            }

        }
    }

// ----------------------------------------------------
// CMceUi::SetMainViewActivatedFlag
//
// ----------------------------------------------------
void CMceUi::SetMainViewActivatedFlag( )
    {
    iMceUiFlags.SetMceFlag( EMceUiFlagsMainViewActivated );
    }

// ---------------------------------------------------------
// CMceUi::AlwaysOnlineL
// This is static function
// Returns ETrue if always online is supported
// ---------------------------------------------------------
TBool CMceUi::AlwaysOnlineL( )
    {
    TBool alwaysOnline = EFalse;
     if ( FeatureManager::FeatureSupported( KFeatureIdAlwaysOnLine )
        && FeatureManager::FeatureSupported( KFeatureIdAlwaysOnLineEmail ) )
        {
        TInt featureBitmask = 0;

        CRepository* repository = NULL;
        TRAPD( ret, repository = CRepository::NewL(KCRUidMuiuVariation) );
        CleanupStack::PushL( repository );

        if ( ret == KErrNone )
            {
            if ( repository->Get(KMuiuEmailConfigFlags,featureBitmask) != KErrNone )
                {
                alwaysOnline = EFalse;
                }
            else
                {
                alwaysOnline = featureBitmask & KEmailFeatureIdAlwaysOnline;
                }
            }

        CleanupStack::Pop( repository );
        delete repository;

        }

    return alwaysOnline;
    }

// ----------------------------------------------------
// CMceUi::RemoveFolderTabs
// ----------------------------------------------------
void CMceUi::RemoveFolderTabs()
    {
    MCELOGGER_ENTERFN("RemoveFolderTabs()");

    iNaviPane->Pop( iFolderIndicator );

    MCELOGGER_LEAVEFN("RemoveFolderTabs()");
    }

// ----------------------------------------------------
// CMceUi::ShowFolderTabsL
// ----------------------------------------------------
void CMceUi::ShowFolderTabsL( const TInt aDepth )
    {
    MCELOGGER_ENTERFN("ShowFolderTabsL()");

    CMceNaviPaneFolderIndicator* findicator =
        static_cast<CMceNaviPaneFolderIndicator*>( iFolderIndicator->DecoratedControl() );

    findicator->SetFolderDepth( aDepth );
    iNaviPane->PushL( *iFolderIndicator );

    MCELOGGER_LEAVEFN("ShowFolderTabsL()");
    }

// ----------------------------------------------------
// CMceUi::HandleMMSNotificationsDeleteL
//
// ----------------------------------------------------
void CMceUi::HandleMMSNotificationsDeleteL( TDes8& aParameter )
    {
    CBaseMtmUiData* uiData = NULL;
    uiData = GetMtmUiDataL( KUidMsgMMSNotification );

    TMsvId selId = iMMSNotifications->At(0);
    TMsvId mmsService;
    TMsvEntry mmsEntry;
    if ( uiData && iSession->GetEntry( selId, mmsService, mmsEntry ) == KErrNone  )
        {
        CBaseMtmUi& mtmUi=iMtmStore->GetMtmUiAndSetContextLC( mmsEntry );
        CMsvSingleOpWatcher* tempSingleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
        CleanupStack::PushL( tempSingleOpWatcher );

        CMsvOperation* tempOp=mtmUi.InvokeAsyncFunctionL( KMtmUiFunctionDeleteMessage, *iMMSNotifications,
            tempSingleOpWatcher->iStatus, aParameter );

        if ( tempOp )
            {
            CleanupStack::PushL( tempOp );
            iOperations.AppendL( tempSingleOpWatcher );
            CleanupStack::Pop(2); // tempSingleOpWatcher, tempOp
            tempSingleOpWatcher->SetOperation( tempOp );
            }
        else
            {
            // User answered 'No' to the confirmation query and
            // NULL operation was returned
            CleanupStack::PopAndDestroy( tempSingleOpWatcher );
            if( iMMSNotifications )
                {
                delete iMMSNotifications;
                iMMSNotifications = NULL;
                }
            }
        CleanupStack::PopAndDestroy( ); // mtmUi
        }

    }

// ----------------------------------------------------
// CMceUi::CheckMMSNotificationsL
//
// ----------------------------------------------------
void CMceUi::CheckMMSNotificationsL( CMsvEntrySelection* aSelection )
    {
    TMsvId id;
    TMsvId service;
    TMsvEntry tEntry;
    CBaseMtmUiData* uiData = NULL;
    uiData = GetMtmUiDataL( KUidMsgMMSNotification );

    if ( iMMSNotifications )
        {
        delete iMMSNotifications;
        iMMSNotifications = NULL;
        }
    iMMSNotifications = new( ELeave ) CMsvEntrySelection();

    for ( TInt cc=aSelection->Count(); --cc>=0; )
        {
        id = aSelection->At(cc);
        if ( iSession->GetEntry( id, service, tEntry ) == KErrNone  )
            {
            if ( tEntry.iMtm == KUidMsgMMSNotification )
                {
                if ( uiData && !uiData->OperationSupportedL( KMtmUiFunctionDeleteMessage, tEntry ) )
                    {
                    iMMSNotifications->AppendL( tEntry.Id() );
                    aSelection->Delete( cc );
                    }
                else
                    {
                    aSelection->Delete( cc );
                    }
                }
            }
        }

    }

// ----------------------------------------------------
// CMceUi::OpenMailboxSettingsL
// ----------------------------------------------------
void CMceUi::OpenMailboxSettingsL()
    {
    MCELOGGER_ENTERFN("OpenMailboxSettingsL()");

    if ( MceViewActive( EMceMainViewActive ) )
        {
        return;
        }

    // Is settings opened from General Settings
    CMuiuLock* repositoryLock = CMuiuLock::NewL( KMuiuLockSettings );
    CleanupStack::PushL(repositoryLock);
    TInt err = repositoryLock->Reserve();
    // Check that settings are not opened from General Settings
    if ( !err )
        {
        iMceListView->OpenMailboxSettingsL();
        }
    else
        {
        // Show information note: General Settings has opened settings
        CAknNoteDialog* dlg = new (ELeave) CAknNoteDialog(
            CAknNoteDialog::ENoTone, CAknNoteDialog::ELongTimeout);
        dlg->ExecuteLD(R_MCE_NOTE_SETTINGS_OPEN_GS);
        }
    repositoryLock->Release();
    CleanupStack::PopAndDestroy( repositoryLock );

    MCELOGGER_LEAVEFN("OpenMailboxSettingsL");
    }

// ----------------------------------------------------
// CMceUi::SyncMlMarkAsReadL
// ----------------------------------------------------
void CMceUi::SyncMlMarkAsReadL( )
    {
    if ( MceViewActive( EMceMainViewActive ) )
        {
        return;
        }

    CMsvEntrySelection * selection = iMceListView->ListContainer()
        ->CurrentItemSelectionL();
    CleanupStack::PushL( selection );

    if (  selection->Count() <= 0 )
        {
        CleanupStack::PopAndDestroy( selection );
        return;
        }

    CBaseMtmUi& mtmUi = iMtmStore->GetMtmUiLC( KSenduiMtmSyncMLEmailUid );

    CMsvSingleOpWatcher* tempSingleOpWatcher=CMsvSingleOpWatcher::NewL( *this );
    CleanupStack::PushL( tempSingleOpWatcher );
    TBuf8<1> blankParams;

    CMsvOperation* tempOp = mtmUi.InvokeAsyncFunctionL( KMtmUiFunctionMarkAsRead, *selection,
        tempSingleOpWatcher->iStatus, blankParams );

    CleanupStack::PushL( tempOp );
    iOperations.AppendL( tempSingleOpWatcher );
    CleanupStack::Pop( 2 ); // tempSingleOpWatcher, tempOp
    tempSingleOpWatcher->SetOperation( tempOp );
    CleanupStack::PopAndDestroy( 2 ); // mtmUi, selection
    }

// ----------------------------------------------------
// CMceUi::CheckMMSNotifDelFailedL
// ----------------------------------------------------
void CMceUi::CheckMMSNotifDelFailedL()
    {
    MCELOGGER_ENTERFN("CheckMMSNotifDelFailedL()");

    CBaseMtmUiData* data = GetMtmUiDataL( KUidMsgMMSNotification );
    if ( data )
        {
        TInt count = iMMSNotifications->Count();
        TInt failed = 0;
        TMsvId serviceId;
        for(TInt loop = 0; loop < count; loop++)
            {
            TMsvEntry entry;
            if ( iSession->GetEntry(iMMSNotifications->At(loop),serviceId,entry) == KErrNone )
            	{
            	if ( !( entry.iMtmData2 & KMmsNewOperationForbidden ) &&
                	!( entry.iMtmData2 & KMmsOperationOngoing ) &&
                	( entry.iMtmData2 & KMmsOperationFinished ) &&
                	( entry.iMtmData2 & KMmsOperationResult ) )
                	{
                	failed++;               
                	}
            	}
            } // end loop


        if ( failed > 0 )
            {
            CAknQueryDialog* note = CAknQueryDialog::NewL();
            HBufC* text = NULL;
            if ( failed == KMceOneMMSNotificationFailed )
                {
                text = StringLoader::LoadLC(
                    R_MMS_INFO_REMOTE_DEL_FAILED, iEikonEnv );
                note->SetPromptL( *text );
                note->ExecuteLD( R_MCE_MEMC_NOTE );
                CleanupStack::PopAndDestroy(  ); // text
                }
            else
                {
                CArrayFix<TInt>* indexArray =
                     new( ELeave ) CArrayFixFlat<TInt>( KMceArrayGranularity );
                CleanupStack::PushL( indexArray );
                indexArray->AppendL( failed );
                indexArray->AppendL( count );
                text = StringLoader::LoadLC(
                    R_MMS_INFO_REMOTE_DEL_FAILED_MANY, *indexArray, iEikonEnv );

                note->SetPromptL( *text );
                note->ExecuteLD( R_MCE_MEMC_NOTE );
                CleanupStack::PopAndDestroy( 2 ); // text, indexArray
                }
           }

       delete iMMSNotifications;
       iMMSNotifications = NULL;
       }

    MCELOGGER_LEAVEFN("CheckMMSNotifDelFailedL");
    }

// ----------------------------------------------------
// CMceUi::AddMultiselectionMTMFunctionsL
// ----------------------------------------------------
void CMceUi::AddMultiselectionMTMFunctionsL(CEikMenuPane& aMenuPane, TInt /*aMenuCommandId*/)
    {
    MCELOGGER_ENTERFN("AddMultiselectionMTMFunctionsL()");
    
    CEikMenuPaneItem::SData data;
    data.iCascadeId = 0;
    data.iFlags = 0;
    TInt cc;
    TInt sendCmd = EMceCmdFirstMTMFunction;
    const TInt count = iMTMFunctionsArray->Count();

    for ( cc = 0; cc < count; cc++ )
        {
        TMsgFunctionInfo& functionInfo = iMTMFunctionsArray->At(cc);
        data.iText = functionInfo.iCaption;
        data.iCommandId = sendCmd;

        if ( ( functionInfo.iFuncId == KMtmUiFunctionMMBox ) &&
            ( MceViewActive( EMceMessageViewActive ) && 
            iMceListView->ListContainer()->CurrentFolderId() 
            == KMsvGlobalInBoxIndexEntryId ) ) //MMS notification
            {
            TInt pos;
            if ( !aMenuPane.MenuItemExists ( sendCmd, pos ) )
                {
                aMenuPane.AddMenuItemL( data, EAknCmdOpen );
                }
            }

        sendCmd++;
        }
    MCELOGGER_LEAVEFN("AddMultiselectionMTMFunctionsL()");
    }

// ----------------------------------------------------
// CMceUi::CheckCspBitL
// ----------------------------------------------------
TBool CMceUi::CheckCspBitL( ) const
    {
    MCELOGGER_ENTERFN("CheckCspBitL()");
    RCustomerServiceProfileCache csp;
    TInt error = csp.Open();
    if ( error )
        {
        return ETrue;
        }

    RMobilePhone::TCspTeleservices params;
    TInt retVal = csp.CspTeleServices( params );
    csp.Close();

    if ( retVal == KErrNone )
        {
        if ( ( params&RMobilePhone::KCspSMCB ) != 0 )
            {
            MCELOGGER_LEAVEFN("CheckCspBitL()");
            // Cell Broadcast CSP bit is on
            return ETrue;
            }
        else
            {
            MCELOGGER_LEAVEFN("CheckCspBitL()");
            // Cell Broadcast CSP bit is off
            return EFalse;
            }
        }
    else
        {
        MCELOGGER_LEAVEFN("CheckCspBitL()");
        // Error: By default show the CBS service
        return ETrue;
        }
    }

// ---------------------------------------------------------
// CMceUi::CspBitsL
// Returns ETrue if csp bits is supported
// ---------------------------------------------------------
//
TBool CMceUi::CspBitsL( )
    {
    TBool csp = EFalse;
    TInt featureBitmask = 0;

    CRepository* repository = NULL;
    TRAPD( ret, repository = CRepository::NewL(KCRUidMuiuVariation) );
    CleanupStack::PushL( repository );

    if ( ret == KErrNone )
        {
        if ( repository->Get(KMuiuMceFeatures,featureBitmask) != KErrNone )
            {
            csp = EFalse;
            }
        else
            {
            csp = featureBitmask & KMceFeatureIdCSPSupport;
            }
        }

    CleanupStack::Pop( repository );
    delete repository;

    return csp;
    }

// ---------------------------------------------------------
// CMmsViewerAppUi::DoUploadL
// ---------------------------------------------------------
void CMceUi::DoUploadL( TInt aIndex )
    {
    TInt i = aIndex;
    CSendingServiceInfo* info = iUploadServices[ i ];
    TMsgUploadParameters uploadParams;
    uploadParams.iDirect = ( info->ServiceProviderId() == KMmsDirectUpload );
    uploadParams.iRealAddress = info->ServiceAddress();
    uploadParams.iAlias = info->ServiceName();

    // Pack upload parameters
    TPckgBuf<TMsgUploadParameters> param( uploadParams );

    // Current selection
    CMsvEntrySelection* selection = iMceListView->ListContainer()->CurrentItemSelectionL();
    CleanupStack::PushL( selection );

    CAknInputBlock::NewLC();
    CMuiuOperationWait* wait =
        CMuiuOperationWait::NewLC( EActivePriorityWsEvents + 10 );

// Get a handle of the MMS MTM
    CBaseMtmUi& mtmUi = iMtmStore->GetMtmUiLC( KSenduiMtmMmsUid );

    CMsvOperation* oper = mtmUi.InvokeAsyncFunctionL(
        KMtmUiFunctionUpload,
        *selection,
        wait->iStatus,
        param );
    CleanupStack::PushL( oper );

    wait->Start();

    CleanupStack::PopAndDestroy( 5, selection ); // selection, CAknInputBlock, wait, oper
    }

// ---------------------------------------------------------
// CMceUi::ShowUploadQueryL
// ---------------------------------------------------------
void CMceUi::ShowUploadQueryL()
    {
    TInt count = iUploadServices.Count();

    TInt selectedIndex = 0;
    CAknListQueryDialog* dlg = new ( ELeave )
        CAknListQueryDialog( &selectedIndex );
    dlg->PrepareLC( R_MCE_UPLOAD_LIST_QUERY );

    // Populate list query array
    CDesCArrayFlat* array = new ( ELeave ) CDesCArrayFlat( 4 );
    CleanupStack::PushL( array );
    for ( TInt i = 0; i < count; i++ )
        {
        array->AppendL( iUploadServices[ i ]->ServiceMenuName() );
        }
    dlg->SetItemTextArray( array );
    CleanupStack::Pop( array );

    if ( dlg->RunLD() )
        {
        DoUploadL( selectedIndex );
        }

    }

// MMS.Content.Upload
// ---------------------------------------------------------
// CMceUi::NumUploadServices
// ---------------------------------------------------------
TInt CMceUi::NumUploadServices()
    {
    return iUploadServices.Count();
    }

// ---------------------------------------------------------
// CMceUi::HandleNotifL
// ---------------------------------------------------------
void CMceUi::HandleNotif()
    {
    if ( !iEmailNotifHandler )
        {
        // Handling of NCN reset
        TRAPD( err, iEmailNotifHandler = CMceEmailNotifHandler::NewL() );
        MCELOGGER_WRITE_FORMAT("ConstructL iEmailNotifHandler err %d", err);
        if ( err )
            {
            iEmailNotifHandler = NULL;
            }
        }
    if (iEmailNotifHandler)
        iEmailNotifHandler->HandleNotif();
    }

// ---------------------------------------------------------
// CMceUi::HandleNotifL
// ---------------------------------------------------------
void CMceUi::HandleNotif(const TMsvId& aMailbox)
    {
    if ( !iEmailNotifHandler )
        {
        // Handling of NCN reset
        TRAPD( err, iEmailNotifHandler = CMceEmailNotifHandler::NewL() );
        if ( err )
            {
            iEmailNotifHandler = NULL;
            }
        }
    if ( iEmailNotifHandler )
        {
        iEmailNotifHandler->HandleNotif(aMailbox);
        }
    }

// ---------------------------------------------------------
// CMceUi::CheckSIMAccessProfileL
// ---------------------------------------------------------
void CMceUi::CheckSIMAccessProfileL()
    {
    // P&S key of the SIM access profile
    RProperty property;
    TInt sapState( 0 );
    User::LeaveIfError( property.Attach( KPSUidBluetoothSapConnectionState, KBTSapConnectionState ) );
    CleanupClosePushL( property );
    
    property.Get( sapState );

    if ( (sapState==EBTSapConnecting) || (sapState==EBTSapConnected) )
        {
        // SIM access profile is connecting/connected, MCE is not started
        HBufC* text = StringLoader::LoadLC( R_QTN_OFFLINE_NOT_POSSIBLE_SAP, iEikonEnv );
        // ETrue waiting/non-waiting dialoog
        CAknInformationNote* note = new(ELeave) CAknInformationNote( ETrue );
        note->SetTimeout( CAknNoteDialog::ELongTimeout ); // ELongTimeout
        note->ExecuteLD( *text );
        CleanupStack::PopAndDestroy( text );
        // Exit the application
        CleanupStack::PopAndDestroy( &property );
        Exit();
        }
    else
        {
        CleanupStack::PopAndDestroy( &property );       
        }
    }

// ---------------------------------------------------------
// CMceUi::SetViewUpdateSuppressionFlag
// ---------------------------------------------------------
void CMceUi::SetViewUpdateSuppressionFlag( TBool aValue, CMsvOperation* aOp )
    {
    if ( aValue )
        {
        iMceUiFlags.SetMceFlag( EMceUiFlagsSupressViewUpdate );
        iBlockingOperation = aOp;
        }
    else
        {
        iMceUiFlags.ClearMceFlag( EMceUiFlagsSupressViewUpdate );
        iBlockingOperation = NULL;
        }

    }

// ---------------------------------------------------------
// CMceUi::ViewUpdateSuppressionFlag
// ---------------------------------------------------------
TBool CMceUi::ViewUpdateSuppressionFlag()
    {
    return iMceUiFlags.MceFlag( EMceUiFlagsSupressViewUpdate );
    }

// ---------------------------------------------------------
// CMceUi::ReleaseMtmUiData
// ---------------------------------------------------------
void CMceUi::ReleaseMtmUiData()
    {
    MCELOGGER_ENTERFN("ReleaseMtmUiData()");
    const TInt count = iUiRegistry->NumRegisteredMtmDlls();
    MCELOGGER_WRITE_FORMAT("Mtm cound %d", count);

    for ( TInt i = 0; i < count; i++ )
        {
        TUid uid = iUiRegistry->MtmTypeUid(i);
        if ( !MceUtils::IsMtmBuiltIn(uid) )
            {
            iMtmStore->ReleaseMtmUiData( uid );
            }
        }
    MCELOGGER_LEAVEFN("ReleaseMtmUiData()");
    }

// ---------------------------------------------------------
// CMceUi::InformationNoteCannotMoveCopyEMailL
// ---------------------------------------------------------
void CMceUi::InformationNoteCannotMoveCopyEMailL()
    {
    HBufC* errorText = StringLoader::LoadL( R_MCE_INFO_CANNOT_MOVE, iEikonEnv );
    CleanupStack::PushL( errorText );
    CAknInformationNote* note = new(ELeave)CAknInformationNote( ETrue );
    note->ExecuteLD(*errorText);
    CleanupStack::PopAndDestroy( errorText );
    }

// ---------------------------------------------------------
// CMceUi::RemoveEmailMessagesFromSelection
// ---------------------------------------------------------
TBool CMceUi::RemoveEmailMessagesFromSelection( CMsvEntrySelection *aSelection )
    {
    TBool mailMessage = EFalse;
    TInt count = aSelection->Count();
    TMsvId service;
    TMsvEntry tEntry;

    for ( TInt cc=count; --cc>=0; )
        {
        TMsvId id = aSelection->At(cc);
        if ( iSession->GetEntry( id, service, tEntry ) == KErrNone  )
            {
            if ( tEntry.iMtm==KSenduiMtmImap4Uid || tEntry.iMtm==KSenduiMtmPop3Uid ||
                 tEntry.iMtm==KSenduiMtmSmtpUid )
                {
                aSelection->Delete( cc );
                mailMessage = ETrue;
                }
            }
        }

    return mailMessage;
    }

// ---------------------------------------------------------
// CMceUi::MailboxCreationOn
// ---------------------------------------------------------
TBool CMceUi::MailboxCreationOn()
    {
    return iMailboxCreationOn;
    }

// ---------------------------------------------------------
// CMceUi::ZoomLevelChangedL
// ---------------------------------------------------------
TAknUiZoom CMceUi::ZoomLevelChangedL( TAknUiZoom aZoomLevel )
    {
    TAknUiZoom previous = LocalUiZoom();
    if ( aZoomLevel != previous &&
        !iMceUiFlags.MceFlag( EMceUiFlagsSettingsDialogOpen ) )
        {
        SetLocalUiZoom( aZoomLevel );
        ApplyLayoutChangeL( ETrue );
        }
    return previous;
    }

// ---------------------------------------------------------
// CMceUi::ReadZoomLevelL
// ---------------------------------------------------------
TAknUiZoom CMceUi::ReadZoomLevelL()
    {
    TInt zoomValue = EAknUiZoomAutomatic;
    CRepository* repository = NULL;
    TRAPD( ret, repository = CRepository::NewL(KCRUidMuiuSettings) );
    if ( ret == KErrNone )
        {
        CleanupStack::PushL( repository );
        if ( repository->Get(KMuiuZoomValue, zoomValue) != KErrNone )
            {
            zoomValue = EAknUiZoomAutomatic;
            }
        CleanupStack::PopAndDestroy( repository );
        }
    return (TAknUiZoom) zoomValue;
    }

// ---------------------------------------------------------
// CMceUi::WriteZoomLevelL
// ---------------------------------------------------------
void CMceUi::WriteZoomLevelL( TAknUiZoom aZoomLevel )
    {
    CRepository* repository = NULL;
    TRAPD( ret, repository = CRepository::NewL(KCRUidMuiuSettings) );
    if ( ret == KErrNone )
        {
        CleanupStack::PushL( repository );
        if ( repository->Set(KMuiuZoomValue, aZoomLevel) != KErrNone )
            {
            // hmm, just ignore?
            }
        CleanupStack::PopAndDestroy( repository );
        }
    }

// ---------------------------------------------------------
// CMceUi::HandleZoomLevelChangeL
// ---------------------------------------------------------
void CMceUi::HandleZoomLevelChangeL( TInt aCommand )
    {
    TAknUiZoom uiZoom;
    switch ( aCommand )
        {
        default:
        case EMceCmdZoomValueAutomatic:
           uiZoom = EAknUiZoomAutomatic;
           break;
        case EMceCmdZoomValueLarge:
           uiZoom = EAknUiZoomLarge;
           break;
        case EMceCmdZoomValueMedium:
           uiZoom = EAknUiZoomNormal;
           break;
        case EMceCmdZoomValueSmall:
           uiZoom = EAknUiZoomSmall;
           break;
        }

    TAknUiZoom previousZoom = ZoomLevelChangedL( uiZoom );
    if ( previousZoom != uiZoom )
        {
        WriteZoomLevelL( uiZoom );
        }
    }

// ---------------------------------------------------------
// CMceUi::HandleZoomSubMenu
// ---------------------------------------------------------
void CMceUi::HandleZoomSubMenu( CEikMenuPane* aMenuPane )
    {
    TAknUiZoom currentLevel = LocalUiZoom();
    TInt buttonId = EMceCmdZoomValueAutomatic;
    switch ( currentLevel )
        {
        default:
        case EAknUiZoomAutomatic:
            buttonId = EMceCmdZoomValueAutomatic;
            break;
        case EAknUiZoomLarge:
            buttonId = EMceCmdZoomValueLarge;
            break;
        case EAknUiZoomNormal:
            buttonId = EMceCmdZoomValueMedium;
            break;
        case EAknUiZoomSmall:
            buttonId = EMceCmdZoomValueSmall;
            break;
        }
    aMenuPane->SetItemButtonState( buttonId, EEikMenuItemSymbolOn );
    }

// ----------------------------------------------------
// CMceUi::ForwardL
//
// ----------------------------------------------------
void CMceUi::ForwardL(TInt /*aForwardCommand*/)
    {
    MCELOGGER_ENTERFN( "MceUi::ForwardL()----Start>>>>" );

    LeaveIfDiskSpaceUnderCriticalLevelL( iDiskSpaceForMoveOrCopy );

    if ( MceViewActive( EMceMainViewActive ) )
        {
        return;
        }

    CMsvEntrySelection * selection = iMceListView->ListContainer()->CurrentItemSelectionL();
    CleanupStack::PushL( selection );
    if ( selection->Count() <= 0)
        {
        CleanupStack::PopAndDestroy( selection );
        return;
        }

    TMsvEntry entry;
    TMsvId serviceId;
    User::LeaveIfError( iSession->GetEntry(selection->At(0),serviceId,entry) );
    CleanupStack::PopAndDestroy( selection );

    TMsvPartList parts = KMsvMessagePartBody | KMsvMessagePartOriginator | KMsvMessagePartDescription | KMsvMessagePartAttachments;

    CBaseMtmUi& ui=iMtmStore->GetMtmUiAndSetContextLC( entry );
    ui.SetPreferences( ui.Preferences() | EMtmUiFlagEditorPreferEmbedded );
    CAknInputBlock::NewLC();
    CMsvSingleOpWatcher* singleOpWatcher = CMsvSingleOpWatcher::NewL( *this );
    CleanupStack::PushL( singleOpWatcher );

    CMsvOperation* oper = ui.ForwardL(
        KMsvDraftEntryIdValue, parts, singleOpWatcher->iStatus );

    CleanupStack::PushL( oper );
    iOperations.AppendL( singleOpWatcher );
    CleanupStack::Pop( 2, singleOpWatcher ); // oper
    singleOpWatcher->SetOperation( oper );
    MCELOGGER_WRITE_FORMAT( "iOperations.AppendL(%d)", oper->Id() );
    CleanupStack::PopAndDestroy( 2 ); // CAknInputBlock, ui

    MCELOGGER_LEAVEFN( "MceUi::ForwardL()----End<<<<" );

    }

// ----------------------------------------------------
// CMceUi::HandleNewMsgToInboxL
// Remove New Flag from selected message(s) if there is any
// From 5.0
// ----------------------------------------------------
void CMceUi::HandleNewMsgToInboxL( TBool removeNewFlag, CMsvEntrySelection* aSelection )
    {
    TMsvEntry aEntry;

    if ( !removeNewFlag && ( !iIdArray ) )
        {
        return;
        }
    else if( removeNewFlag )
        {
        if ( iIdArray )
            {
            delete iIdArray;
            iIdArray = NULL;
            }
        iIdArray = new ( ELeave ) CMsvEntrySelection;
        for (TInt i = 0; i < aSelection->Count(); ++i )
            {
            TMsvId selectedId = aSelection->At(i);
            iEntry->SetEntryL( selectedId );
            aEntry = iEntry->Entry();
            if ( aEntry.Unread() )
                {
                iIdArray->AppendL( selectedId );
                aEntry.SetUnread( EFalse );
                iEntry->ChangeL( aEntry );
                }
            }
        if ( iIdArray->Count() )
            {
            iHandleNewMsgToInbox = ETrue;
            }
        }
    else
        {
        for ( TInt i = 0; i < iIdArray->Count(); ++i )
            {
            iEntry->SetEntryL( iIdArray->At(i) );
            aEntry = iEntry->Entry();
            aEntry.SetUnread( ETrue );
            iEntry->ChangeL( aEntry );
            }
        delete iIdArray;
        iIdArray = NULL;
        iHandleNewMsgToInbox = EFalse;
        }
    }


// ----------------------------------------------------
// TBool CMceUi::HasNewEmailL
// Check if there is new email the the folder
// public
// ----------------------------------------------------
TBool CMceUi::HasNewEmailL( TMsvId aFolderId )
    {
    CMsvEntry* entry = iSession->GetEntryL( aFolderId );
    CleanupStack::PushL( entry );

    TBool newEmail = EFalse;
    const TInt count = entry->Count();
    for ( TInt loop = 0; loop < count ; loop++ )
        {
        if ( (*entry)[loop].iType.iUid != KUidMsvFolderEntryValue )
            {
            if ( (*entry)[loop].New() )
                {
                newEmail = ETrue;
                break;
                }
            }
        }
    CleanupStack::PopAndDestroy( entry );
    return newEmail;
    }

// ----------------------------------------------------
// void CMceUi::SetDiskSpaceForMoveOrCopyL
// Reads critical and warning levels from cenrep
// ----------------------------------------------------
void CMceUi::SetDiskSpaceForMoveOrCopyL( )
    {
    // If can't open cenrep use default value
    iDiskSpaceForMoveOrCopy = KMceDiskSpaceForMoveOrCopy;
    TInt diskWarningThreshold = 0;
    TInt diskCriticalThreshold = 0;
    
    CRepository* repository = NULL;
    TRAPD( ret, repository = CRepository::NewL( KCRUidUiklaf ) );

    if ( ret == KErrNone )
        {
        CleanupStack::PushL( repository );
        if ( repository->Get( KUikOODDiskWarningThreshold, 
             diskWarningThreshold ) == KErrNone && 
             repository->Get( KUikOODDiskCriticalThreshold,
             diskCriticalThreshold ) == KErrNone )
            {
            iDiskSpaceForMoveOrCopy = diskWarningThreshold 
            - diskCriticalThreshold;        
            }
        CleanupStack::PopAndDestroy( repository );
        }

    }
// ----------------------------------------------------
// CMceUi::LaunchUniEditorL
// ----------------------------------------------------
//    
void CMceUi::LaunchUniEditorL()
    {
    //KUidUniMtm 0x102072D6
    CreateNewMessageL( KSenduiMtmUniMessageUidValue ); 
    }    
    
// ----------------------------------------------------
// CMceUi::GetToBeCreatedEmailType
// ----------------------------------------------------
//
 TInt CMceUi::GetToBeCreatedEmailType ()
    {
    // not sure if it's save
    TInt messageType = KErrNone;
    if ( MceViewActive( EMceMessageViewActive ) && iMceListView )
        {
        const TMsvEntry& entry = iMceListView->ListContainer()->FolderEntry();
        if ( entry.iMtm == KSenduiMtmImap4Uid
            || entry.iMtm == KSenduiMtmPop3Uid ) 
            {
            messageType = KSenduiMtmSmtpUidValue;
            }
        else
            {
             messageType = entry.iMtm.iUid;
            }
        }
    return messageType;
    }
    
// ----------------------------------------------------
// CMceUi::HideOrExit
// ----------------------------------------------------
void CMceUi::HideOrExit()
    {
    SetDontExitOnNextOperationComplete();
    iMceUiFlags.ClearMceFlag( EMceUiFlagsWantToExit );
    if (ExitHidesInBackground())
        {
        // Always use exit effect even if this is actually application switch
		// Note: Not allowed to call GfxTransEffect::EndFullScreen() as AVKON takes care of that when
		// EApplicationExit context is used!  
		// Set effect begin point
		GfxTransEffect::BeginFullScreen( AknTransEffect::EApplicationExit, TRect(), 
			AknTransEffect::EParameterType, AknTransEffect::GfxTransParam(TUid::Uid( KMceApplicationUidValue )) );       

        ResetAndHide();
        }
    else
        {
        CAknEnv::RunAppShutter();
        }
    }

// ----------------------------------------------------
// CMceUi::ResetAndHide
// ----------------------------------------------------
void CMceUi::ResetAndHide()
    {
    SetCustomControl(1);    // Disable bring-to-foreground on view activation
    TRAP_IGNORE( CAknViewAppUi::CreateActivateViewEventL( \
        KMessagingCentreMainViewUid, \
        TUid::Uid(KMceHideInBackground), \
        KNullDesC8 ) ) ;
    HideInBackground();
    }
void CMceUi::OpenMtmMailboxViewL( const TMsvEntry& aEntry )
	{
    CBaseMtmUi& mtmUi=iMtmStore->GetMtmUiAndSetContextLC( aEntry );

    CMsvSingleOpWatcher* singleOpWatcher=CMsvSingleOpWatcher::NewL( *this );
    CleanupStack::PushL( singleOpWatcher );

    CMsvOperation* op = NULL;
    TRAPD( error, ( op=mtmUi.OpenL(singleOpWatcher->iStatus ) ) );
    
    CleanupStack::PushL( op );
    iOperations.AppendL( singleOpWatcher );
    CleanupStack::Pop( op );
    CleanupStack::Pop( singleOpWatcher );
    
    singleOpWatcher->SetOperation( op );
    
    // Destroys mtmUi object insted of PopAndDestroy
    iMtmStore->ReleaseMtmUi( mtmUi.Type() );
	}

// ----------------------------------------------------
// CMceUi::FindMtmInVisibleListL
// ----------------------------------------------------
TBool CMceUi::FindMtmInVisibleListL( TUid aMtm, CArrayFix<TUid>& aListItemUids )
    {
    for ( TInt i = 0 ; i < aListItemUids.Count() ; i++)
        {
        if( aMtm == aListItemUids[i] )
            {
            return ETrue;
            }
        }
    return EFalse;
    }
// ----------------------------------------------------
// CMceUi::GetMsgDeletedStatus
// ----------------------------------------------------    
TInt CMceUi::GetMsgDeletedStatus()
    {
    return iMsgDeletedStatus;	
    }
// ----------------------------------------------------
// CMceUi::SetMsgDeletedStatus
// ----------------------------------------------------
void CMceUi::SetMsgDeletedStatus(TBool aStatus)
    {
    iMsgDeletedStatus = aStatus;	
    }

// ----------------------------------------------------
// CMceUi::GetFsIntegratedEmailAppMtmPluginId
// ----------------------------------------------------
TUid CMceUi::GetFsIntegratedEmailAppMtmPluginId()
    {
    TUid uidMsgValTypeEmailMtmVal = TUid::Uid(0);
     if ( (iEmailClientIntegration )&& (!iEmailFramework))
        {
        CRepository* repository = NULL;
        TInt mtmPluginID = 0;
        TRAPD( ret, repository = CRepository::NewL(
                                 KCRUidSelectableDefaultEmailSettings ) );
        
        if ( ret == KErrNone )
            {
            // Get Email application mtm plugin ID
            repository->Get( KIntegratedEmailAppMtmPluginId, mtmPluginID );
            }
        delete repository;
        uidMsgValTypeEmailMtmVal = TUid::Uid( mtmPluginID );       
        }
     return uidMsgValTypeEmailMtmVal;
    }
//CR:422-271
// ----------------------------------------------------
// CMceUi::PopulateMMSTemplates
// ----------------------------------------------------
TInt CMceUi::PopulateMMSTemplates()
    {

    TInt error = KErrNone;
    TInt numErrors = 0;
    TInt errorIncrement = 0;
    
    //first try if the directory of mms dump exists or not
    _LIT(KTopDir,"C:\\Private\\1000484b\\");
      
    _LIT( KWild, "mmsvar" );

    TFindFile finder( iFs );
    error = finder.FindByDir(KWild,KTopDir);

    if ( error !=KErrNone )
        {
        return;
        }
    // Reset inactivity timer to keep viewServer from crashing  
    User::ResetInactivityTime();
    
    TFileName CurrentPath;
    CurrentPath.Copy( KMmsMessageDumpDirectory );
    
    TRAP( error, errorIncrement = DecodeAllMMSFromDirectoryL( CurrentPath,KMsvGlobalInBoxIndexEntryId) );
    numErrors += errorIncrement;
    if ( error != KErrNone )
        {
      //"left with error "
        	numErrors++;
        	error = KErrNone;
        }
    if ( errorIncrement > 0 )
        {
        //("- returned errors")
        }
	User::ResetInactivityTime();
	return numErrors;
}
// ----------------------------------------------------
// CMceUi::DecodeAllMMSFromDirectoryL
// ----------------------------------------------------
TInt CMceUi::DecodeAllMMSFromDirectoryL( TFileName& aFilePath, TMsvId aBoxid /*= KMsvGlobalInBoxIndexEntryId*/ )
    {
    TInt numErrors = 0;
    TInt error = KErrNone;
    _LIT( KWild, "*" );

    CDir* fileList = NULL;
    TInt i = 0;  // general counter
    TFileName Filename;
    TFileName CurrentPath = aFilePath;
    if ( CurrentPath[CurrentPath.Length()-1] != '\\' )
    CurrentPath.Append( '\\' );
    iFs.SetSessionPath( CurrentPath );

    TFindFile finder( iFs );
    error = finder.FindWildByPath( KWild, NULL, fileList );
    CleanupStack::PushL( fileList );
    TInt fileCounter = 0;

    if ( error == KErrNone )
        {
        fileCounter = fileList->Count();
        }
    TEntry entry;

    if ( error == KErrNone )
        {
        for ( i = 0; i < fileCounter; i++ )
            {
            // Reset inactivity timer to keep viewServer from crashing  
            User::ResetInactivityTime();
            entry = (*fileList)[i]; // name is entry.iName
            Filename.Copy( entry.iName );
            if (!entry.IsDir())
                {
                TRAP( error, DecodeMMSFromFileL( Filename, aBoxid ));
                if ( error != KErrNone )
                    {
                        //There are errors in decoding the files
                    }
                iFs.Delete(entry.iName);
                }

             }
            
        }

    CleanupStack::PopAndDestroy(); // fileList
    fileList = NULL;

    return numErrors;
    }
// ----------------------------------------------------
// CMceUi::DecodeFromFileL
// ----------------------------------------------------
TInt CMceUi::DecodeMMSFromFileL( TFileName& aFilePath, TMsvId aBoxId /* KMsvGlobalInBoxIndexEntryId*/, TUint32 aFlags /*= 0*/ )
    {
    TInt numErrors = 0;
    TInt error = KErrNone;
    TMsvId id;
        
    FillBufferFromFileL( aFilePath, iFs, iEncodeBuffer );
        
    CMmsCodecClient* codecClient = CMmsCodecClient::NewL( *iSession );
    CleanupStack::PushL( codecClient );
    
    TBool unread = EFalse;
    
    TRAP( error, codecClient->InitializeChunkedAddingL( aBoxId, id, aFlags, unread ) ); 
    if ( error != KErrNone )
        {
        numErrors++;
        }
    
    if ( error == KErrNone )
        {
        error = FeedDataInChunks( codecClient );
        }
        
    if ( error != KErrNone )
        {
        numErrors++;
        }
    
    // Not needed can be cleaned up
    CMsvEntry* cEntry = iSession->GetEntryL( id );
    TMsvEntry entry = cEntry->Entry();

    entry.SetReadOnly(ETrue);
    entry.iServiceId = KMsvLocalServiceIndexEntryId;
    entry.iMtmData1 = KMmsMessageMRetrieveConf | KMmsMessageMobileTerminated;
    entry.SetUnread(EFalse);
    
    
    cEntry->ChangeL(entry); 
    CleanupStack::PopAndDestroy( codecClient );
       
    return numErrors;
    }
// ----------------------------------------------------
// CMceUi::FeedDataInChunks
// ----------------------------------------------------
TInt CMceUi::FeedDataInChunks( CMmsCodecClient* aCodecClient )
    {
    
    TInt error = KErrNone;
    TInt chunkSize = KMmsCodecClientChunkSize;
    TInt size = iEncodeBuffer->Size();
    
    // Number of full chunks
    TInt chunkNumber = size / chunkSize;
    TInt remainder = size % chunkSize;
    
    TInt pos = 0;    
    TPtrC8 messagePtr( iEncodeBuffer->Ptr( 0 ) );
    
    TBool lastChunk = EFalse;
    TInt i = 0;
    for ( i = 0; i < chunkNumber && error == KErrNone; i++ )
        {
        pos = i * chunkSize;
        TPtrC8 ptr( iEncodeBuffer->Ptr( 0 ).Mid( pos, chunkSize ) );
        error = aCodecClient->NextDataPart( ptr, lastChunk );
        }
        
    // last chunk
    if ( remainder > 0 && error == KErrNone )
        {
        TPtrC8 ptr2( iEncodeBuffer->Ptr( size - remainder ) );
        if ( ptr2.Length() > 0 )
            {
            error = aCodecClient->NextDataPart( ptr2, lastChunk );
            }
        }
        
    lastChunk = ETrue;
    TPtrC8 ptr3;
    if ( error == KErrNone )
        {
        aCodecClient->NextDataPart( ptr3, lastChunk );
        }
    return error;    
    
    }
// ----------------------------------------------------
// CMceUi::FillBufferFromFileL
// ----------------------------------------------------
void CMceUi::FillBufferFromFileL(
    const TDesC& aFilePath,
    RFs& aFs,
    CBufFlat* aEncodeBuffer )
    {
    TInt error = KErrNone;
    TEntry orgEntry;
    error = aFs.Entry( aFilePath, orgEntry );
    TInt size = orgEntry.iSize;
    RFile inFile;
    if ( aEncodeBuffer == NULL )
        {
        aEncodeBuffer = CBufFlat::NewL( size );
        }
    else
        {
        aEncodeBuffer->ResizeL( 0 );
        aEncodeBuffer->ResizeL( size );
        }

    error = inFile.Open( aFs, aFilePath, EFileShareReadersOnly );
    
    TPtr8 ptr = aEncodeBuffer->Ptr( 0 );
    if ( error == KErrNone )
        {
        error = inFile.Read( ptr, size );
        inFile.Close();
        }
    else
        {
        //"*** - can't read file"
        }
    User::LeaveIfError( error );    
    
    }
//CR:422-271
// end of file

// end of file
