/*

* 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 <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 );

                }