/*
* Copyright (c) 2006-2008 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:  Main view
*
*/



// INCLUDE FILES
#include <aknlists.h>
#include <CFileManagerEngine.h>
#include <CFileManagerItemProperties.h>
#include <FileManager.rsg>
#include <csxhelp/fmgr.hlp.hrh>
#include <FileManagerDlgUtils.h>
#include <FileManagerDebug.h>
#include <CFileManagerFeatureManager.h>
#include <coreapplicationuisdomainpskeys.h>
#include <StringLoader.h>
#include <cmemstatepopup.h>
#include "CFileManagerMainView.h"
#include "CFileManagerFileListContainer.h"
#include "CFileManagerAppUi.h"
#include "CFileManagerDocument.h"
#include "FileManager.hrh"


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

// ----------------------------------------------------------------------------
// CFileManagerMainView::CFileManagerMainView
// ----------------------------------------------------------------------------
//
CFileManagerMainView::CFileManagerMainView()
    {
    }

// ----------------------------------------------------------------------------
// CFileManagerMainView::NewLC
// ----------------------------------------------------------------------------
//
CFileManagerMainView* CFileManagerMainView::NewLC()
    {
    CFileManagerMainView* self = new( ELeave ) CFileManagerMainView();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ----------------------------------------------------------------------------
// CFileManagerMainView::ConstructL
// ----------------------------------------------------------------------------
//
void CFileManagerMainView::ConstructL()
    {
    CFileManagerViewBase::ConstructL(
        FeatureManager().IsEmbedded() ?
            R_FILEMANAGER_MAIN_VIEW_EMBEDDED :
            R_FILEMANAGER_MAIN_VIEW );
    }

// ----------------------------------------------------------------------------
// CFileManagerMainView::~CFileManagerMainView
// ----------------------------------------------------------------------------
// 
CFileManagerMainView::~CFileManagerMainView()
    {
    }

// ----------------------------------------------------------------------------
// CFileManagerMainView::DoActivateL
// ----------------------------------------------------------------------------
// 
void CFileManagerMainView::DoActivateL(
        const TVwsViewId& aPrevViewId,
        TUid aCustomMessageId,
        const TDesC8& aCustomMessage )
    {
    FUNC_LOG

    CFileManagerViewBase::DoActivateL(
        aPrevViewId, aCustomMessageId, aCustomMessage );

    // Ensure that no directory is defined
    if ( iEngine.CurrentDirectory().Length() )
        {
        TInt count( iEngine.NavigationLevel() );
        ++count;
        for ( TInt i( 0 ); i < count; i++ )
            {
            TRAP_IGNORE( iEngine.BackstepL() );
            }
        }

    CFileManagerAppUi* appUi = 
        static_cast< CFileManagerAppUi* >( AppUi() );
    appUi->RestoreDefaultTitleL();
    iEngine.SetState( CFileManagerEngine::ENavigation );
    iEngine.SetObserver( this );
    appUi->ExitEmbeddedAppIfNeededL();
    if ( !appUi->WaitingForInputParams() )
        {
        iEngine.RefreshDirectory();
        }
    }

// ----------------------------------------------------------------------------
// CFileManagerMainView::DoDeactivate
// ----------------------------------------------------------------------------
// 
void CFileManagerMainView::DoDeactivate()
    {
    FUNC_LOG

    CFileManagerViewBase::DoDeactivate();
    }

// ----------------------------------------------------------------------------
// CFileManagerMainView::DirectoryChangedL
// ----------------------------------------------------------------------------
// 
void CFileManagerMainView::DirectoryChangedL()
    {
    FUNC_LOG

    CFileManagerAppUi* appUi = 
        static_cast< CFileManagerAppUi* >( AppUi() );

    if ( iContainer && !appUi->WaitingForInputParams() )
        {
        iContainer->RefreshListL( iIndex );
        }
    }

// ----------------------------------------------------------------------------
// CFileManagerMainView::Id
// ----------------------------------------------------------------------------
// 
TUid CFileManagerMainView::Id() const
    {
    return CFileManagerAppUi::KFileManagerMainViewId;
    }

// ----------------------------------------------------------------------------
// CFileManagerMainView::CreateContainerL
// ----------------------------------------------------------------------------
// 
CFileManagerContainerBase* CFileManagerMainView::CreateContainerL()
    {
    return CFileManagerFileListContainer::NewL(
        ClientRect(),
        iIndex,
        CFileManagerFileListContainer::EListMain,
        R_QTN_SELEC_EMPTY_LIST,
        KFMGR_HLP_MAIN_VIEW );
    }

// ----------------------------------------------------------------------------
// CFileManagerMainView::DynInitMenuPaneL
// ----------------------------------------------------------------------------
// 
void CFileManagerMainView::DynInitMenuPaneL(
        TInt aResourceId, 
        CEikMenuPane* aMenuPane)
    {
    switch( aResourceId )
        {
        // These menus are used only by main view
        case R_FILEMANAGER_MAIN_VIEW_MENU:
            {
            MainMenuFilteringL( *aMenuPane );
            break;
            }
        case R_FILEMANAGER_REMOTE_DRIVES_MENU:
            {
            RemoteDrivesMenuFilteringL( *aMenuPane );
            break;
            }
        case R_FILEMANAGER_MEMORY_STORAGE_MENU:
            {
            MemoryStorageMenuFilteringL( *aMenuPane );
            break;
            }
        default:
            {
            CFileManagerViewBase::DynInitMenuPaneL( aResourceId, aMenuPane );
            break;
            }
        }
    }

// ----------------------------------------------------------------------------
// CFileManagerMainView::MainMenuFilteringL
// ----------------------------------------------------------------------------
//
void CFileManagerMainView::MainMenuFilteringL( CEikMenuPane& aMenuPane )
    {
    RemoteDriveCommonFilteringL( aMenuPane );

    if ( !iContainer->ListBoxNumberOfItems() )
        {
        aMenuPane.SetItemDimmed( EFileManagerEject, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerFindFile, ETrue );
#ifndef RD_FILE_MANAGER_BACKUP
        aMenuPane.SetItemDimmed( EFileManagerBackup, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerRestore, ETrue );
#endif // RD_FILE_MANAGER_BACKUP
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorage, ETrue );
        return;
        }

    if ( !FeatureManager().IsRemoteStorageFwSupported() )
        {
        aMenuPane.SetItemDimmed( EFileManagerRemoveDrives, ETrue );
        }

    CFileManagerItemProperties* prop = iEngine.GetItemInfoLC(
        iContainer->ListBoxCurrentItemIndex() );
    TUint32 drvState( 0 );
    if ( prop->IsDrive() )
        {
        iEngine.DriveState( drvState, prop->FullPath() );
        }

    TFileManagerDriveInfo drvInfo;
    if ( DriveInfoAtCurrentPosL( drvInfo ) < 0 )
        {
        // No drive selected
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorage, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerEject, ETrue );
        }
    else
        {
        if ( !( drvInfo.iState & TFileManagerDriveInfo::EDriveEjectable ) ||
             !( drvInfo.iState & TFileManagerDriveInfo::EDrivePresent ) )
            {
            aMenuPane.SetItemDimmed( EFileManagerEject, ETrue );
            }
        if ( ( drvInfo.iState & TFileManagerDriveInfo::EDriveRemovable ) && 
            !( drvInfo.iState & TFileManagerDriveInfo::EDrivePresent ) )
            {
            aMenuPane.SetItemDimmed( EFileManagerMemoryStorage, ETrue );
            }
        if ( drvInfo.iState & TFileManagerDriveInfo::EDriveRemote )
            {
            aMenuPane.SetItemDimmed( EFileManagerMemoryStorage, ETrue );
            }
        }

#ifndef RD_FILE_MANAGER_BACKUP
    TFileManagerDriveInfo mmcinfo( iEngine.GetMMCInfoL() );
    if ( mmcinfo.iState & ( TFileManagerDriveInfo::EDriveLocked |
                            TFileManagerDriveInfo::EDriveCorrupted ) )
        {
        aMenuPane.SetItemDimmed( EFileManagerBackup, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerRestore, ETrue );
        }
    else if ( !( mmcinfo.iState & TFileManagerDriveInfo::EDrivePresent ) )
        {
        aMenuPane.SetItemDimmed( EFileManagerBackup, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerRestore, ETrue );
        }
    else if ( !( mmcinfo.iState & TFileManagerDriveInfo::EDriveBackupped ) )
        {
        aMenuPane.SetItemDimmed( EFileManagerRestore, ETrue );
        }
    if ( FeatureManager().IsEmbedded() )
        {
        // Disable backup in embedded mode, because it messes up 
        // backup and restore operations since embedded apps are closed.
        aMenuPane.SetItemDimmed( EFileManagerBackup, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerRestore, ETrue );
        }
#endif // RD_FILE_MANAGER_BACKUP

    CleanupStack::PopAndDestroy( prop );
    }

// ----------------------------------------------------------------------------
// CFileManagerMainView::RemoteDrivesMenuFilteringL
// ----------------------------------------------------------------------------
//
void CFileManagerMainView::RemoteDrivesMenuFilteringL(
        CEikMenuPane& aMenuPane )
    {
    TInt index( iContainer->ListBoxCurrentItemIndex() );
    CFileManagerItemProperties* prop = iEngine.GetItemInfoLC( index );
    TUint32 drvState( 0 );
    if ( iEngine.DriveState( drvState, prop->FullPath() ) == KErrNone )
        {
        if ( !( drvState & TFileManagerDriveInfo::EDriveRemote ) ||
             ( drvState & TFileManagerDriveInfo::EDriveConnected ) )
            {
            aMenuPane.SetItemDimmed(
                EFileManagerRemoveDrivesSettings, ETrue );
            aMenuPane.SetItemDimmed(
                EFileManagerRemoveDrivesDelete, ETrue );
            }
        }
    else
        {
        aMenuPane.SetItemDimmed( EFileManagerRemoveDrivesSettings, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerRemoveDrivesDelete, ETrue );
        }
    CleanupStack::PopAndDestroy( prop );
	TBool dimAll( EFalse );
	if ( !FeatureManager().IsRemoteStorageFwSupported() )
		{
		dimAll = ETrue;
		}
	else
		{
		if ( drvState & TFileManagerDriveInfo::EDriveRemote )
		    {
			if ( drvState & TFileManagerDriveInfo::EDriveConnected )
			    {
				aMenuPane.SetItemDimmed( EFileManagerConnectRemoveDrive, ETrue );
				}
			else
				{
				aMenuPane.SetItemDimmed( EFileManagerDisconnectRemoveDrive,ETrue );
				}
			}
		else
			{
			dimAll = ETrue;
			}
		}
		
	if ( dimAll )
        {
	    aMenuPane.SetItemDimmed( EFileManagerConnectRemoveDrive, ETrue );
	    aMenuPane.SetItemDimmed( EFileManagerDisconnectRemoveDrive, ETrue );
        }
    }

// ----------------------------------------------------------------------------
// CFileManagerMainView::HandleCommandL
// ----------------------------------------------------------------------------
// 
void CFileManagerMainView::HandleCommandL( TInt aCommand )
    {
    switch( aCommand )
        {
        case EFileManagerOpen:
            {
            CmdOpenMemoryStoreL();
            break;
            }
        case EFileManagerEject:
            {
            CmdEjectL();
            break;
            }
#ifndef RD_FILE_MANAGER_BACKUP
        case EFileManagerBackup:
            {
            CmdBackupL();
            break;
            }
        case EFileManagerRestore:
            {
            CmdRestoreL();
            break;
            }
#endif // RD_FILE_MANAGER_BACKUP
        case EFileManagerRemoveDrivesMapDrive:
            {
            CmdMapRemoteDriveL();
            break;
            }
        case EFileManagerRemoveDrivesSettings:
            {
            CmdRemoteDriveSettingsL();
            break;
            }
        case EFileManagerDelete: // Fall through
        case EFileManagerRemoveDrivesDelete:
            {
            CmdRemoteDriveDeleteL();
            break;
            }
        case EFileManagerSend: // Suppress
            {
            break;
            }
        case EFileManagerMemoryStorageDetails:
            {
            CmdMemoryStorageDetailsL();
            break;
            }
        case EFileManagerMemoryStorageName:
        case EFileManagerMemoryStorageRename: // Fall through
            {
            CmdRenameDriveL();
            break;
            }
        case EFileManagerMemoryStorageFormat:
            {
            CmdFormatDriveL();
            break;
            }
        case EFileManagerMemoryStorageSetPassword:
            {
            CmdSetDrivePasswordL();
            break;
            }
        case EFileManagerMemoryStorageChangePassword:
            {
            CmdChangeDrivePasswordL();
            break;
            }
        case EFileManagerMemoryStorageRemovePassword:
            {
            CmdRemoveDrivePasswordL();
            break;
            }
        case EFileManagerMemoryStorageUnlock:
            {
            CmdUnlockDriveL();
            break;
            }
        default:
            {
            CFileManagerViewBase::HandleCommandL( aCommand );
            break;
            }
        }
    }

// ----------------------------------------------------------------------------
// CFileManagerMainView::CmdOpenMemoryStoreL
// ----------------------------------------------------------------------------
// 
void CFileManagerMainView::CmdOpenMemoryStoreL()
    {
    StoreIndex();
    TInt index( iContainer->ListBoxCurrentItemIndex() );
    if ( index >= 0 )
        {
        CFileManagerAppUi* appUi = 
            static_cast< CFileManagerAppUi* >( AppUi() );
        CFileManagerItemProperties* prop = iEngine.GetItemInfoLC( index );

        TRAPD( err, iEngine.OpenL( index ) );
        if ( err == KErrNone && prop->FullPath().Length() )
            {
            appUi->ActivateMemoryStoreViewL();
            }
        CleanupStack::PopAndDestroy( prop );
        }
    }

// ----------------------------------------------------------------------------
// CFileManagerMainView::CmdEjectL
// ----------------------------------------------------------------------------
//
void CFileManagerMainView::CmdEjectL()
    {
    StoreIndex();

#ifdef RD_MULTIPLE_DRIVE
    TInt index( iContainer->ListBoxCurrentItemIndex() );
    CFileManagerItemProperties* prop = iEngine.GetItemInfoLC( index );
    TInt drive( prop->DriveId() );
    const TInt KDriveShift = 16;

    // Let SysAp handle eject
    RProperty::Set(
        KPSUidCoreApplicationUIs,
        KCoreAppUIsMmcRemovedWithoutEject,
        ECoreAppUIsEjectCommandUsedToDrive | ( drive << KDriveShift )
        );

    CleanupStack::PopAndDestroy( prop );
#else // RD_MULTIPLE_DRIVE
    if ( FileManagerDlgUtils::ShowConfirmQueryWithYesNoL( R_QTN_CONF_EJECT ) )
        {
        StartProcessL( EEjectProcess );
        }
#endif // RD_MULTIPLE_DRIVE
    }

#ifndef RD_FILE_MANAGER_BACKUP
// ----------------------------------------------------------------------------
// CFileManagerMainView::CmdBackupL
//
// ----------------------------------------------------------------------------
//
void CFileManagerMainView::CmdBackupL()
    {
    StoreIndex();
    TInt textId( R_QTN_CONFIRM_BACKUP_TEXT );
    TFileManagerDriveInfo mmcinfo( iEngine.GetMMCInfoL() );

    if( mmcinfo.iState & TFileManagerDriveInfo::EDriveBackupped )
        {
        textId = R_QTN_CONFIRM_BACKUP_TEXT2;
        }
    if( FileManagerDlgUtils::ShowConfirmQueryWithYesNoL( textId ) )
        {
        if ( !DriveReadOnlyMmcL( mmcinfo.iDrive ) )
            {
            if ( !IsDriveAvailable( mmcinfo.iDrive ) || 
                !CheckPhoneState() )
                {
                FileManagerDlgUtils::ShowErrorNoteL( R_QTN_CRITICAL_ERROR );
                }
            else
                {
                StartProcessL( EBackupProcess );
                }
            }
        }
    }

// ----------------------------------------------------------------------------
// CFileManagerMainView::CmdRestoreL
// ----------------------------------------------------------------------------
//
void CFileManagerMainView::CmdRestoreL()
    {
    StoreIndex();
    if( FileManagerDlgUtils::ShowConfirmQueryWithYesNoL( R_QTN_CONFIRM_RESTORE_TEXT ) )
        {
        TFileManagerDriveInfo mmcinfo( iEngine.GetMMCInfoL() );
        
        if ( !IsDriveAvailable( mmcinfo.iDrive ) || 
            !CheckPhoneState() )
            {
            FileManagerDlgUtils::ShowErrorNoteL( R_QTN_CRITICAL_ERROR );
            }
        else
            {
            StartProcessL( ERestoreProcess );
            }
        }
    }
#endif // RD_FILE_MANAGER_BACKUP

// ----------------------------------------------------------------------------
// CFileManagerMainView::CmdMapRemoteDriveL
// ----------------------------------------------------------------------------
//
void CFileManagerMainView::CmdMapRemoteDriveL()
    {
    StoreIndex();
    const TInt KMaxRemoteDrives = 9;
    RFs& fs( CCoeEnv::Static()->FsSession() );
    TDriveList driveList;
    User::LeaveIfError( fs.DriveList( driveList, KDriveAttRemote ) );
    TInt numRemote( 0 );
    TInt count( driveList.Length() );
    for( TInt i( 0 ); i < count; ++i )
        {
        if ( driveList[ i ] & KDriveAttRemote )
            {
            ++numRemote;
            }
        }
    if ( numRemote < KMaxRemoteDrives )
        {
        OpenRemoteDriveSettingsL();
        }
    else
        {
        FileManagerDlgUtils::ShowConfirmQueryWithOkL(
            FileManagerDlgUtils::EErrorIcons,
            R_QTN_RD_ERROR_MAX_DRIVES );
        }
    }

// ----------------------------------------------------------------------------
// CFileManagerMainView::CmdRemoteDriveSettingsL
// ------------------------------------------------------------------------------
//
void CFileManagerMainView::CmdRemoteDriveSettingsL()
    {
    StoreIndex();
    TInt index( iContainer->ListBoxCurrentItemIndex() );
    CFileManagerItemProperties* prop = iEngine.GetItemInfoLC( index );
    OpenRemoteDriveSettingsL( prop->DriveName() );
    CleanupStack::PopAndDestroy( prop );
    }

// ------------------------------------------------------------------------------
// CFileManagerMainView::CmdRemoteDriveDeleteL
//
// ------------------------------------------------------------------------------
//
void CFileManagerMainView::CmdRemoteDriveDeleteL()
    {
    StoreIndex();
    TInt index( iContainer->ListBoxCurrentItemIndex() );
    CFileManagerItemProperties* prop = iEngine.GetItemInfoLC( index );
    if ( IsDisconnectedRemoteDrive( *prop ) )
        {
        if ( FileManagerDlgUtils::ShowConfirmQueryWithYesNoL(
                R_QTN_RD_QUERY_DELETE_DRIVE, prop->Name() ) )
            {
            TInt drv = TDriveUnit( prop->FullPath() );
            User::LeaveIfError( iEngine.DeleteRemoteDrive( drv ) );
            }
        }
    CleanupStack::PopAndDestroy( prop );
    }

// ------------------------------------------------------------------------------
// CFileManagerMainView::NotifyL
//
// ------------------------------------------------------------------------------
//
TInt CFileManagerMainView::NotifyL(
        TFileManagerNotify aType, TInt aData, const TDesC& aName )
    {
    TInt ret( KErrNone );
    switch ( aType )
        {
#ifdef RD_FILE_MANAGER_BACKUP
        case ENotifyActionSelected:
            {
            if ( aData == EFileManagerBackupAction )
                {
                StoreIndex();
                CFileManagerAppUi* appUi = 
                    static_cast< CFileManagerAppUi* >( AppUi() );
                appUi->ActivateBackupViewL();
                }
            break;
            }
#endif // RD_FILE_MANAGER_BACKUP
        default:
            {
            ret = CFileManagerViewBase::NotifyL( aType, aData, aName );
            break;
            }
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// CFileManagerMainView::MemoryStorageMenuFilteringL
// -----------------------------------------------------------------------------
// 
void CFileManagerMainView::MemoryStorageMenuFilteringL( CEikMenuPane& aMenuPane )
    {
    TFileManagerDriveInfo drvInfo;
    if( DriveInfoAtCurrentPosL( drvInfo ) < 0 )
        {
        // No drive selected
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageUnlock, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageDetails, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageFormat, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageName, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageRename, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageSetPassword, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageChangePassword, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageRemovePassword, ETrue );
        return;
        }

    if ( drvInfo.iState & TFileManagerDriveInfo::EDriveCorrupted )
        {
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageDetails, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageName, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageRename, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageSetPassword, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageChangePassword, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageRemovePassword, ETrue );
        }
    else if ( !( drvInfo.iState & TFileManagerDriveInfo::EDriveRemovable ) || 
              ( drvInfo.iState & ( TFileManagerDriveInfo::EDriveLocked |
                                   TFileManagerDriveInfo::EDriveMassStorage ) ) )
        {
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageName, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageRename, ETrue );
        }
    else if ( drvInfo.iName.Length() > 0 )
        {
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageName, ETrue );
        }
    else
        {
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageRename, ETrue );
        }
    if (!( drvInfo.iState & TFileManagerDriveInfo::EDrivePresent) )
    	{
			aMenuPane.SetItemDimmed(EFileManagerMemoryStorageSetPassword, ETrue );
			aMenuPane.SetItemDimmed(EFileManagerMemoryStorageName, ETrue );
			aMenuPane.SetItemDimmed(EFileManagerMemoryStorageRename, ETrue );
			aMenuPane.SetItemDimmed(EFileManagerMemoryStorageDetails, ETrue );
			
    	}

    if ( FeatureManager().IsEmbedded() ||
         !( drvInfo.iState & TFileManagerDriveInfo::EDriveRemovable ) ||
         !( drvInfo.iState & TFileManagerDriveInfo::EDriveFormattable ) )
        {
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageFormat, ETrue );
        }
        
    if ( drvInfo.iState & TFileManagerDriveInfo::EDriveLocked )
        {
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageDetails, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageSetPassword, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageChangePassword, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageRemovePassword, ETrue );
        }
    else
        {
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageUnlock, ETrue );
        }

    if ( !( drvInfo.iState & TFileManagerDriveInfo::EDriveRemovable ) ||
         ( drvInfo.iState & ( TFileManagerDriveInfo::EDriveMassStorage |
                              TFileManagerDriveInfo::EDriveUsbMemory ) ) )
        {
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageSetPassword, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageChangePassword, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageRemovePassword, ETrue );
        }
    else if ( drvInfo.iState & TFileManagerDriveInfo::EDrivePasswordProtected ) 
        {
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageSetPassword, ETrue );
        }
    else
        {
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageChangePassword, ETrue );
        aMenuPane.SetItemDimmed( EFileManagerMemoryStorageRemovePassword, ETrue );
        }
    }

// ------------------------------------------------------------------------------
// CFileManagerMainView::CmdMemoryStorageDetailsL
// ------------------------------------------------------------------------------
//
void CFileManagerMainView::CmdMemoryStorageDetailsL()
    {
    StoreIndex();
    TFileManagerDriveInfo drvInfo;
    TInt drive( DriveInfoAtCurrentPosL( drvInfo ) );
    if ( drive < 0 )
        {
        return; // No drive selected
        }
    HBufC* title = StringLoader::LoadLC( R_QTN_FMGR_MSTATE_HEADING );
    CMemStatePopup::RunLD(
        static_cast< TDriveNumber >( drive ), *title );
    CleanupStack::PopAndDestroy( title );
//    TFileManagerDriveInfo drvInfo;
//    iEngine.GetDriveInfoL( iEngine.CurrentDrive(), drvInfo );
//    FileManagerDlgUtils::ShowMemoryStoreInfoPopupL( drvInfo );
    }

// ------------------------------------------------------------------------------
// CFileManagerMainView::CmdRenameDriveL
// ------------------------------------------------------------------------------
//
void CFileManagerMainView::CmdRenameDriveL()
    {
    StoreIndex();
    TFileManagerDriveInfo drvInfo;
    if ( DriveInfoAtCurrentPosL( drvInfo ) < 0 )
        {
        return; // No drive selected
        }
    if ( drvInfo.iState & TFileManagerDriveInfo::EDriveWriteProtected )
        {
        FileManagerDlgUtils::ShowErrorNoteL( R_QTN_MEMORYCARD_READONLY );
        return;
        }
    RenameDriveL( EFalse );
    iEngine.SetObserver( this );
    iEngine.RefreshDirectory();
    }

// ------------------------------------------------------------------------------
// CFileManagerMainView::CmdSetDrivePasswordL
// ------------------------------------------------------------------------------
//
void CFileManagerMainView::CmdSetDrivePasswordL()
    {
    StoreIndex();
    TInt drive( DriveAtCurrentPosL() );
    if ( drive < 0 )
        {
        return; // No drive selected
        }

    TBuf< KFmgrMaxMediaPassword > pwd;
    if( FileManagerDlgUtils::ShowPasswordQueryL( pwd ) )
        {
        TBuf< KFmgrMaxMediaPassword > nullPwd;
        EmptyPwd( nullPwd );
        if( UpdatePassword( drive, nullPwd, pwd ) == KErrNone )
            {
            FileManagerDlgUtils::ShowConfirmNoteL( R_QTN_PASSWORD_SET_TEXT );
            }
        else
            {
            FileManagerDlgUtils::ShowErrorNoteL( R_QTN_CRITICAL_ERROR );
            }
        }
    }

// ------------------------------------------------------------------------------
// CFileManagerMainView::CmdChangeDrivePasswordL
// ------------------------------------------------------------------------------
//
void CFileManagerMainView::CmdChangeDrivePasswordL()
    {
    StoreIndex();
    TInt drive( DriveAtCurrentPosL() );
    if ( drive < 0 )
        {
        return; // No drive selected
        }

    TBuf< KFmgrMaxMediaPassword > pwd;
    TBuf< KFmgrMaxMediaPassword > oldPwd;
    TBool isDone( EFalse );
    TBool isCanceled( EFalse );
    TInt err( KErrNone );

    // Ask for the old password until the correct one is given
    while( !isDone )
        {
        EmptyPwd( oldPwd );
        if( FileManagerDlgUtils::ShowSimplePasswordQueryL(
                R_QTN_PASSWORD_OLD_TEXT, oldPwd ) )
			{
			TInt index(iContainer->ListBoxCurrentItemIndex());
						CFileManagerItemProperties* prop = iEngine.GetItemInfoLC(index);
						TUint32 drvState(0);
						TInt error= iEngine.DriveState(drvState, prop->FullPath());
						if ((error!=KErrNone)||(!(drvState & TFileManagerDriveInfo::EDrivePresent)))
							{
							isDone = ETrue;
							isCanceled = ETrue;
							FileManagerDlgUtils::ShowErrorNoteL(R_QTN_MEMC_NOT_AVAILABLE );
							}
						else
            {
            err = UpdatePassword( drive, oldPwd, oldPwd );
            if( err == KErrNone )
                {
                isDone = ETrue;
                }
            else
                {
                FileManagerDlgUtils::ShowErrorNoteL(
                    R_QTN_PASSWORDS_WRONG_TEXT );
                }
            }
						CleanupStack::PopAndDestroy( prop );
						}
        else
            {
            isDone = ETrue;
            isCanceled = ETrue;
            }
        }

    // Then query for the new password
    if( !isCanceled )
        {
        if( FileManagerDlgUtils::ShowPasswordQueryL( pwd ) )
            {
            err = UpdatePassword( drive, oldPwd, pwd );
            if( err == KErrNone )
                {
                FileManagerDlgUtils::ShowConfirmNoteL(
                    R_QTN_PASSWORD_CHANGED_TEXT );
                }
            else
                {
                FileManagerDlgUtils::ShowErrorNoteL(
                    R_QTN_CRITICAL_ERROR );
                }
            }
        }
    }

// ------------------------------------------------------------------------------
// CFileManagerMainView::CmdRemoveDrivePasswordL
// ------------------------------------------------------------------------------
//
void CFileManagerMainView::CmdRemoveDrivePasswordL()
    {
    StoreIndex();
    TInt drive( DriveAtCurrentPosL() );
    if ( drive < 0 )
        {
        return; // No drive selected
        }

    if( !UnlockRemovePasswordL( drive, ETrue ) )
        {
        FileManagerDlgUtils::ShowConfirmNoteL( R_QTN_PASSWORD_REMOVED_TEXT );
        }
    }

// ------------------------------------------------------------------------------
// CFileManagerMainView::DriveAtCurrentPosL
// ------------------------------------------------------------------------------
//
TInt CFileManagerMainView::DriveAtCurrentPosL()
    {
    TFileManagerDriveInfo dummy;
    return DriveInfoAtCurrentPosL( dummy );
    }

//  End of File