/*

* Copyright (c) 2002-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:  Base class for all file manager views

*

*/

// INCLUDE FILES

#include <aknlists.h>

#include <eikmenup.h> // CEikMenuPane

#include <eikmenub.h> // CEikMenuBar

#include <StringLoader.h>

#include <AknCommonDialogs.h> // Common File Dialogs

#include <CAknMemorySelectionDialog.h>

#include <CAknFileSelectionDialog.h>

#include <sendui.h>

#include <Sendnorm.rsg>

#include <SenduiMtmUids.h>

#include <AknProgressDialog.h>

#include <eikprogi.h>

#include <AknWaitNoteWrapper.h>

#include <aknnotewrappers.h>

#include <AknWaitDialog.h>

#include <cmemstatepopup.h>

#include <f32file.h>

#include <aknmessagequerydialog.h>

#include <CMessageData.h>

#include <DRMHelper.h>

#include <bautils.h>

#include <AknCommonDialogsDynMem.h>

#include "CFileManagerViewBase.h"

#include "CFileManagerContainerBase.h"

#include "CFileManagerAppUi.h"

#include "CFileManagerDocument.h"

#include "CFileManagerFileSelectionFilter.h"

#include "FileManager.hrh"

#ifdef RD_FILE_MANAGER_BACKUP

 #include "CFileManagerSchBackupHandler.h"

 #include "CFileManagerBackupSettings.h"

 #include "CFileManagerTaskScheduler.h"

#endif // RD_FILE_MANAGER_BACKUP

#include <CFileManagerEngine.h>

#include <CFileManagerUtils.h>

#include <CFileManagerCommonDefinitions.h>

#include <CFileManagerItemProperties.h>

#include <CFileManagerActiveExecute.h>

#include <Cfilemanageractivedelete.h>

#include <FileManager.rsg>

#include <FileManagerView.rsg>

#include <FileManagerDebug.h>

#include <FileManagerDlgUtils.h>

#include <CFileManagerFeatureManager.h>

#include <FileManagerPrivateCRKeys.h>

#include <DataSyncInternalPSKeys.h>

#include <connect/sbdefs.h>

#include <e32property.h>

#include <caf/caf.h>

#include <drmagents.h>

using namespace conn;

// CONSTANTS

const TUint KMessageSize = 1024;

const TUint KMaxPercentage = 100;

const TUint KProgressBarUpdateInterval = 1000000; // microseconds

const TUint KDriveLetterSize = 1;

const TUint KRefreshProgressStartDelay = 1000000; // microseconds

const TInt KFmgrMSK = 3;

const TInt KEstimateUpperLimit = 90; // User selectable continuation

const TInt KEstimateLowerLimit = 10; // Backup will be interrupted

const TUint32 KDefaultFolderMask = CFileManagerItemProperties::EFolder |

                                  CFileManagerItemProperties::EDefault;

const TInt64 KMSecToMicroSecMultiplier = 1000000;

const TInt64 KMinToMicroSecMultiplier = KMSecToMicroSecMultiplier * 60;

const TInt64 KHourToMicroSecMultiplier = KMinToMicroSecMultiplier * 60;

const TUint KProgressBarAsyncStartDelay = 1500000; // microseconds

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

// -----------------------------------------------------------------------------

// IsWmDrmFile

// 

// -----------------------------------------------------------------------------

// 

static TBool IsWmDrmFile( const TDesC& aFullPath )

    {

    TBool ret( EFalse );

    ContentAccess::CContent* content = NULL;

    TRAPD( err, content = ContentAccess::CContent::CContent::NewL(

        aFullPath, EContentShareReadWrite ) );

    if ( err != KErrNone )

        {

        TRAP( err, content = ContentAccess::CContent::CContent::NewL(

            aFullPath, EContentShareReadOnly ) );

        }

    if ( err == KErrNone )

        {

        TInt isProtected( 0 );

        err = content->GetAttribute( EIsProtected, isProtected );

        if ( err == KErrNone && isProtected )

            {

            TInt fileType( 0 );

            err = content->GetAttribute( DRM::EDrmFileType, fileType );

            ret = ( err == KErrNone && fileType == DRM::EDrmWMFile );

            }

        delete content;

        }

    return ret;

    }

// -----------------------------------------------------------------------------

// Int64ToInt

// 

// -----------------------------------------------------------------------------

// 

static TInt Int64ToInt( const TInt64& aInt64 )

    {

    if ( aInt64 > KMaxTInt )

        {

        return KMaxTInt;

        }

    return I64INT( aInt64 );

    }

// -----------------------------------------------------------------------------

// EmptyPwd

// 

// -----------------------------------------------------------------------------

// 

//static void EmptyPwd( TDes& aPwd )

//    {

//    aPwd.FillZ( aPwd.MaxLength( ) );

//    aPwd.Zero();

//    }

// -----------------------------------------------------------------------------

// ConvertCharsToPwd

// 

// -----------------------------------------------------------------------------

// 

//static void ConvertCharsToPwd( const TDesC& aWord, TDes8& aConverted )

//    {

//    // Make sure the target password is empty ( can't use the function here )

//    aConverted.FillZ( aConverted.MaxLength() );

//    aConverted.Zero();

//    TInt size( aWord.Size() );

//    if ( size )

//        {

//        if ( size > aConverted.MaxLength() )

//            {

//            size = aConverted.MaxLength();

//            }

//        aConverted.Copy( (TUint8*)aWord.Ptr(), size );

//        }

//    }

// -----------------------------------------------------------------------------

// IsSystemProcess

// 

// -----------------------------------------------------------------------------

// 

static TBool IsSystemProcess(

        MFileManagerProcessObserver::TFileManagerProcess aProcess )

    {

    switch ( aProcess )

        {

        case MFileManagerProcessObserver::EFormatProcess:

        case MFileManagerProcessObserver::EBackupProcess:

        case MFileManagerProcessObserver::ERestoreProcess:

        case MFileManagerProcessObserver::ESchBackupProcess:

            {

            return ETrue;

            }

        default:

            {

            break;

            }

        }

    return EFalse;

    }

// -----------------------------------------------------------------------------

// GetDeleteQueryPromptLC

// Chooses correct string for the delete note

// -----------------------------------------------------------------------------

// 

static HBufC* GetDeleteQueryPromptLC( CFileManagerItemProperties& aProp, TInt aCount )

    {

    HBufC* prompt = NULL;

    if ( aCount == 0 && aProp.ContainsAnyFilesOrFolders() )

        {

        prompt = StringLoader::LoadLC( R_QTN_FLDR_DEL_FULL_FLDRS_QUERY );

        }

    else if ( aCount <= 1 )

        {

        prompt = StringLoader::LoadLC( R_QTN_QUERY_COMMON_CONF_DELETE, aProp.NameAndExt() );

        }

    else // aCount > 1

        {

        prompt = StringLoader::LoadLC( R_QTN_FLDR_DEL_ITEMS_QUERY, aCount );

        }

    return prompt;

    }

// -----------------------------------------------------------------------------

// MinIndex

// 

// -----------------------------------------------------------------------------

// 

static TInt MinIndex( CArrayFixFlat<TInt>& aIndexArray )

    {

    TInt count( aIndexArray.Count() );

    if ( !count )

        {

        return 0;

        }

    // Find min index

    TInt index( 0 );

    TInt i( 0 );

    TInt ret( aIndexArray.At( i ) );

    ++i;

    for( ; i < count; ++i )

        {

        index = aIndexArray.At( i );

        if ( index < ret )

            {

            ret = index;

            }

        }

    return ret;

    }

// -----------------------------------------------------------------------------

// SetCurrentYearMonthAndDay

// 

// -----------------------------------------------------------------------------

// 

static TTime SetCurrentYearMonthAndDay( const TTime& aTime )

    {    

    TTime timeNow;

    timeNow.HomeTime();

    TDateTime dateTimeNow( timeNow.DateTime() );

    TInt64 ret( timeNow.Int64() );

    // Replace hours, minutes and seconds using given ones.

    ret -= static_cast< TInt64 >( dateTimeNow.Hour() ) * KHourToMicroSecMultiplier;

    ret -= static_cast< TInt64 >( dateTimeNow.Minute() ) * KMinToMicroSecMultiplier;

    ret -= static_cast< TInt64 >( dateTimeNow.Second() ) * KMSecToMicroSecMultiplier;

    ret -= dateTimeNow.MicroSecond();

    TDateTime dateTime( aTime.DateTime() );

    ret += static_cast< TInt64 >( dateTime.Hour() ) * KHourToMicroSecMultiplier;

    ret += static_cast< TInt64 >( dateTime.Minute() ) * KMinToMicroSecMultiplier;

    ret += static_cast< TInt64 >( dateTime.Second() ) * KMSecToMicroSecMultiplier;

    return ret;

    }

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

// -----------------------------------------------------------------------------

// CFileManagerViewBase::CFileManagerViewBase

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CFileManagerViewBase::CFileManagerViewBase() :

    iEngine( static_cast< CFileManagerDocument* >( AppUi()->Document() )->Engine() )

    {

    }

// -----------------------------------------------------------------------------

// CFileManagerViewBase::~CFileManagerViewBase

// Destructor

// -----------------------------------------------------------------------------

// 

CFileManagerViewBase::~CFileManagerViewBase()

    {

    delete iWaitNoteWrapper;

    delete iActiveDelete;

    delete iPeriodic;

    delete iMarkedArray;

    delete iContainer;

    delete iActiveExec;

    delete iRefreshProgressDelayedStart;

    delete iEjectQueryDialog;

    }

// -----------------------------------------------------------------------------

// CFileManagerViewBase::GetSendFilesLC

// 

// -----------------------------------------------------------------------------

// 

CArrayFixFlat<TInt>* CFileManagerViewBase::GetSendFilesLC( TInt& aSize )

    {

    // Get index array and remove folders and play lists

    CArrayFixFlat< TInt >* ret = MarkedArrayLC();

    TInt i( ret->Count() );

    while ( i > 0 )

        {

        --i;

        // IconIdL() is slow if the icon is not cached yet.

        // However, it is faster than FileTypeL().

        switch ( iEngine.IconIdL( ret->At( i ) ) )

            {

            case EFileManagerFolderIcon: // FALLTHROUGH

            case EFileManagerFolderSubIcon: // FALLTHROUGH

            case EFileManagerFolderEmptyIcon: // FALLTHROUGH

            case EFileManagerPlaylistFileIcon:

                {

                ret->Delete( i );

                break;

                }

            default:

                {

                break;

                }

            }

        }

    aSize = Int64ToInt( iEngine.GetFileSizesL( *ret ) );

    return ret;

    }

// -----------------------------------------------------------------------------

// CFileManagerViewBase::ConstructL

// 

// -----------------------------------------------------------------------------

// 

void CFileManagerViewBase::ConstructL( TInt aResId )

    {

    BaseConstructL( aResId );

    }

// -----------------------------------------------------------------------------

// CFileManagerViewBase::HandleCommandL

// 

// -----------------------------------------------------------------------------

//

void CFileManagerViewBase::HandleCommandL( TInt aCommand )

    {

    if ( !iContainer ) return;

    TBool updateCba( !iContainer->SelectionModeEnabled() );

    switch( aCommand )

        {

        case EFileManagerOpen:

            {

            CmdOpenL();

            break;

            }

        case EFileManagerDelete:

            {

            CmdDeleteL();

            break;

            }

        case EFileManagerMoveToFolder:

            {

            CmdMoveToFolderL();

            break;

            }

        case EFileManagerCopyToFolder:

            {

            CmdCopyToFolderL();

            break;

            }

        case EFileManagerNewFolder:

            {

            CmdNewFolderL();

            break;

            }

        case EFileManagerMarkOne:   // FALLTHROUGH

        case EFileManagerUnmarkOne: // FALLTHROUGH

        case EFileManagerToggleMark:

            {

            CmdToggleMarkL();

            break;

            }

        case EFileManagerMarkAll:

            {

            CmdMarkAllL();

            break;

            }

        case EFileManagerUnmarkAll:

            {

            CmdUnmarkAllL();

            break;

            }

        case EFileManagerRename:

            {

            CmdRenameL();

            break;

            }

        case EFileManagerFindFile:

            {

            CmdFindL();

            break;

            }

        case EFileManagerFileDetails: // FALLTHROUGH

        case EFileManagerFolderDetails: // FALLTHROUGH

        case EFileManagerViewInfo:

            {

            CmdViewInfoL();

            break;

            }

//        case EFileManagerMemoryState:

//            {

//            CmdMemoryStateL();

//            break;

//            }

        case EFileManagerReceiveViaIR:

            {

            CmdReceiveViaIRL();

            break;

            }

        case EFileManagerCheckMark: // Suppress

            {

            break;

            }

        case EAknSoftkeyContextOptions: // FALLTHROUGH

        case EFileManagerSelectionKey:

            {

            TInt count( iContainer->ListBoxSelectionIndexesCount() );

            if ( !count )

                {

                HandleCommandL( EFileManagerOpen );

                }

            else if ( count > 0 )

                {

                ShowContextSensitiveMenuL();

                }

            break;

            }

        case EFileManagerSend:

            {

            if ( !iSendUiPopupOpened )

            {

                SendUiQueryL();

            }

            break;

            }

        case EFileManagerMoreInfoOnline:

            {

            OpenInfoUrlL( iContainer->ListBoxCurrentItemIndex() );

            break;

            }

        case EFileManagerUnlockMemoryCard:

            {

            CmdUnlockDriveL();

            break;

            }

//        case EFileManagerMemoryCardName:

//        case EFileManagerMemoryCardRename: // Fall through

//            {

//            CmdRenameDriveL();

//            break;

//            }

        //case EFileManagerMemoryCardFormat:

        case EFileManagerMemoryStorageFormat:

        case EFileManagerFormatMassStorage: // Fall through

            {

            CmdFormatDriveL();

            break;

            }

//        case EFileManagerMemoryCardPasswordSet:

//            {

//            CmdSetDrivePasswordL();

//            break;

//            }

//        case EFileManagerMemoryCardPasswordChange:

//            {

//            CmdChangeDrivePasswordL();

//            break;

//            }

//        case EFileManagerMemoryCardPasswordRemove:

//            {

//            CmdRemoveDrivePasswordL();

//            break;

//            }

//        case EFileManagerMemoryCardDetails:

//            {

//            CmdMemoryCardDetailsL();

//            break;

//            }

        case EFileManagerConnectRemoveDrive:

            {

            SetRemoteDriveConnectionStateL( ETrue );

            break;

            }

        case EFileManagerDisconnectRemoveDrive:

            {

            SetRemoteDriveConnectionStateL( EFalse );

            break;

            }

        case EFileManagerRefreshRemoteDrive:

            {

            CmdRefreshDirectoryL();

            break;

            }

	    case EFileManagerSortByName:

	    case EFileManagerSortByType: // Fall through

	    case EFileManagerSortMostRecentFirst: // Fall through

	    case EFileManagerSortLargestFirst: // Fall through

	    case EFileManagerSortByMatch: // Fall through

            {

            CmdSortL( aCommand );

            break;

            }

        default:

            {

            AppUi()->HandleCommandL( aCommand );

            break;

            }

        }