--- a/filemanager/App/src/CFileManagerViewBase.cpp Thu Aug 19 09:42:45 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,5194 +0,0 @@
-/*
-* 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
-const TInt64 KMinificationFactor = 1024; // Used to zoom processbar's proportion
-
-// ============================ 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;
- }
- }
-
- if ( updateCba )
- {
- UpdateCbaL();
- }
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::SendUiQueryL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::SendUiQueryL()
- {
- //iSendUiPopupOpened = ETrue;
-
- CSendUi& sendUi( static_cast< CFileManagerAppUi* >( AppUi() )->SendUiL() );
- CMessageData* msgData = CMessageData::NewL();
- CleanupStack::PushL( msgData );
- TInt msgSize( KMessageSize );
- CArrayFixFlat< TInt >* files = GetSendFilesLC( msgSize );
- TInt count( files->Count() );
- if ( count )
- {
- // Set dimmed services specified for FileManager by Send UI spec
- const TInt KDimmedServices = 4;
- CArrayFixFlat< TUid >* servicesToDim =
- new ( ELeave ) CArrayFixFlat< TUid >( KDimmedServices );
- CleanupStack::PushL( servicesToDim );
-
- servicesToDim->AppendL( KSenduiMtmAudioMessageUid );
- servicesToDim->AppendL( KMmsDirectUpload );
- servicesToDim->AppendL( KMmsIndirectUpload );
- servicesToDim->AppendL( KSenduiMtmPostcardUid );
-
- TSendingCapabilities caps(
- 0, msgSize, TSendingCapabilities::ESupportsAttachments );
- for( TInt i( 0 ); i < count ; i++ )
- {
- HBufC* fullPath = iEngine.IndexToFullPathLC( files->At( i ) );
- msgData->AppendAttachmentL( *fullPath );
- CleanupStack::PopAndDestroy( fullPath );
- }
- // Let SendUi handle protected files, queries and filtering
- TRAPD( err, sendUi.ShowQueryAndSendL( msgData, caps, servicesToDim ) );
- if ( err == KErrTooBig )
- {
- FileManagerDlgUtils::ShowErrorNoteL( R_QTN_FMGR_FILE_SIZE_TOO_LARGE );
- }
- else
- {
- User::LeaveIfError( err );
- }
- CleanupStack::PopAndDestroy( servicesToDim );
- }
- CleanupStack::PopAndDestroy( files );
- CleanupStack::PopAndDestroy( msgData );
-
- iSendUiPopupOpened = EFalse;
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::MarkMenuFilteringL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::MarkMenuFilteringL( CEikMenuPane& aMenuPane )
- {
- TInt index( iContainer->ListBoxCurrentItemIndex() );
-
- if ( iEngine.IsFolder( index ) )
- {
- aMenuPane.SetItemDimmed( EFileManagerMarkOne, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerUnmarkOne, ETrue );
- }
- else
- {
- if ( iContainer->ListBoxIsItemSelected( index ) )
- {
- aMenuPane.SetItemDimmed( EFileManagerMarkOne, ETrue );
- }
- else
- {
- aMenuPane.SetItemDimmed( EFileManagerUnmarkOne, ETrue );
- }
- }
- TInt files( 0 );
- if( iContainer->IsSearchFieldVisible() )
- {
- files = FilesCountInSearchField();
- }
- else
- {
- files = iEngine.FilesInFolderL();
- }
- TInt count( iContainer->ListBoxSelectionIndexesCount() );
- if ( count == files )
- {
- aMenuPane.SetItemDimmed( EFileManagerMarkAll, ETrue );
- }
-
- if ( !count )
- {
- aMenuPane.SetItemDimmed( EFileManagerUnmarkAll, ETrue );
- }
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::CmdOpenL
-//
-// -----------------------------------------------------------------------------
-//
-CFileManagerViewBase::TFileManagerOpenResult CFileManagerViewBase::CmdOpenL()
- {
- if ( !iContainer || iActiveProcess != ENoProcess )
- {
- return EOpenError; // Ignore to avoid mess up
- }
- TInt index( iContainer->ListBoxCurrentItemIndex() );
- TInt err( KErrNone );
-
- if ( index < 0 )
- {
- return EOpenError;
- }
- CFileManagerAppUi* appUi =
- static_cast< CFileManagerAppUi* >( AppUi() );
- TBool isFolder( iEngine.IsFolder( index ) );
- StoreIndex();
- TRAP( err, iEngine.OpenL( index ) );
- if ( err == KErrNone )
- {
- if ( isFolder )
- {
- if ( !appUi->ActivateFoldersViewL() )
- {
- // Folders view is already open
- // Refresh if this view is folders view
- if ( Id() == CFileManagerAppUi::KFileManagerFoldersViewId )
- {
- iEngine.SetObserver( this );
- iEngine.RefreshDirectory();
- }
- }
- return EFolderOpened;
- }
- return EFileOpened;
- }
- if ( !HandleFileNotFoundL( err ) )
- {
- if ( !isFolder )
- {
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_FMGR_ERROR_CANT_OPEN );
- }
- }
- return EOpenError;
- }
-
-// ----------------------------------------------------------------------------
-// CFileManagerViewBase::CmdDeleteL
-//
-// ----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::CmdDeleteL()
- {
-
- if ( !iContainer->ListBoxNumberOfItems() )
- {
- // List box is empty, nothing to delete
- return;
- }
-
- const TInt selectionCount(iContainer->ListBoxSelectionIndexesCount() );
- TInt index( iContainer->ListBoxCurrentItemIndex() );
-
- if ( selectionCount == 1 )
- {
- // One item marked
- const CArrayFix< TInt >* items = iContainer->ListBoxSelectionIndexes();
- index = items->At( 0 );
- }
-
- CFileManagerItemProperties* prop = iEngine.GetItemInfoL( index );
- CleanupStack::PushL( prop );
-
- if ( DeleteStatusNotOkL( *prop, selectionCount ) )
- {
- // It is not possible to continue delete operation
- CleanupStack::PopAndDestroy( prop );
- return;
- }
-
- HBufC* prompt = GetDeleteQueryPromptLC( *prop, selectionCount );
-
- TBool ret( EFalse );
- DenyDirectoryRefresh( ETrue );
- TRAPD( err, ret = FileManagerDlgUtils::ShowConfirmQueryWithYesNoL( *prompt ) );
- DenyDirectoryRefresh( EFalse );
- User::LeaveIfError( err );
- if ( ret )
- {
- if( IsDriveAvailable( DriveInfo().iDrive ) )
- {
- DeleteItemsL( index );
- }
- else
- {
- FileManagerDlgUtils::ShowInfoNoteL( R_QTN_MEMC_NOT_AVAILABLE );
- CheckPostponedDirectoryRefresh();
- }
- }
- else
- {
- CheckPostponedDirectoryRefresh();
- }
- CleanupStack::PopAndDestroy( prompt );
- CleanupStack::PopAndDestroy( prop );
-
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::CmdMoveToFolderL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::CmdMoveToFolderL()
- {
-
- if ( DriveReadOnlyMmcL( iEngine.CurrentDirectory() ) )
- {
- return;
- }
-
- // double KMaxFileName is needed if both source and target are KMaxFileName
- HBufC* fileName = HBufC::NewLC( KFmgrDoubleMaxFileName );
- TPtr ptrFileName = fileName->Des();
- CFileManagerFileSelectionFilter* filter =
- new( ELeave ) CFileManagerFileSelectionFilter( iEngine );
- CleanupStack::PushL( filter );
-
- TInt memType(
- AknCommonDialogsDynMem::EMemoryTypePhone |
- AknCommonDialogsDynMem::EMemoryTypeMMC );
-
- if ( FeatureManager().IsRemoteStorageFwSupported() )
- {
- memType |= AknCommonDialogsDynMem::EMemoryTypeRemote;
- }
-
- DenyDirectoryRefresh( ETrue );
- TBool ret( AknCommonDialogsDynMem::RunMoveDlgLD(
- memType,
- ptrFileName,
- R_FILEMANAGER_MOVE_MEMORY_SELECTIONDIALOG,
- filter ) );
- DenyDirectoryRefresh( EFalse );
- CleanupStack::PopAndDestroy( filter );
-
- if ( ret && ptrFileName.Length() )
- {
- if ( !DriveReadOnlyMmcL( ptrFileName ) )
- {
- RunOperationL(
- MFileManagerProcessObserver::EMoveProcess, ptrFileName );
- }
- }
- if (!ret )
- {
- CheckPostponedDirectoryRefresh();
- }
-
- CleanupStack::PopAndDestroy( fileName );
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::CmdCopyToFolderL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::CmdCopyToFolderL()
- {
- // double KMaxFileName is needed if both source and target are KMaxFileName
- HBufC* fileName = HBufC::NewLC( KFmgrDoubleMaxFileName );
- TPtr ptrFileName = fileName->Des();
- CFileManagerFileSelectionFilter* filter =
- new( ELeave ) CFileManagerFileSelectionFilter( iEngine );
- CleanupStack::PushL( filter );
-
- TInt memType(
- AknCommonDialogsDynMem::EMemoryTypePhone |
- AknCommonDialogsDynMem::EMemoryTypeMMC );
-
- if ( FeatureManager().IsRemoteStorageFwSupported() )
- {
- memType |= AknCommonDialogsDynMem::EMemoryTypeRemote;
- }
-
- DenyDirectoryRefresh( ETrue );
- TBool ret( AknCommonDialogsDynMem::RunCopyDlgLD(
- memType,
- ptrFileName,
- R_FILEMANAGER_COPY_MEMORY_SELECTIONDIALOG,
- filter ) );
- DenyDirectoryRefresh( EFalse );
- CleanupStack::PopAndDestroy( filter );
-
- if ( ret && ptrFileName.Length() )
- {
- if ( !DriveReadOnlyMmcL( ptrFileName ) )
- {
- RunOperationL(
- MFileManagerProcessObserver::ECopyProcess, ptrFileName );
- }
- }
- if (!ret )
- {
- CheckPostponedDirectoryRefresh();
- }
- CleanupStack::PopAndDestroy( fileName );
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::CmdNewFolderL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::CmdNewFolderL()
- {
-
- if ( DriveReadOnlyMmcL( iEngine.CurrentDirectory() ) )
- {
- return;
- }
-
- StoreIndex();
-
- if ( !iEngine.EnoughSpaceL(
- iEngine.CurrentDirectory(),
- 0,
- MFileManagerProcessObserver::ENoProcess ) )
- {
- User::Leave( KErrDiskFull );
- }
- HBufC* folderNameBuf = HBufC::NewLC( KMaxFileName );
- TPtr folderName( folderNameBuf->Des() );
-
- if ( FileManagerDlgUtils::ShowFolderNameQueryL(
- R_QTN_FLDR_NAME_PRMPT, folderName, iEngine, ETrue ) )
- {
- TBuf<KMaxPath> fullFolderName( iEngine.CurrentDirectory() );
- fullFolderName.Append( folderName );
- CFileManagerUtils::EnsureFinalBackslash( fullFolderName );
-
- if ( iEngine.IsSystemFolder( fullFolderName ) )
- {
- FileManagerDlgUtils::ShowInfoNoteL( R_QTN_FLDR_NAME_ALREADY_USED, folderName );
- }
- else
- {
- iEngine.NewFolderL( folderName );
- }
- iEngine.SetObserver( this );
- iEngine.RefreshDirectory();
- }
- else
- {
- if ( iContainer && iContainer->IsSearchFieldVisible() )
- {
- iContainer->DrawDeferred();
- }
- }
- CleanupStack::PopAndDestroy( folderNameBuf );
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::CmdToggleMarkL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::CmdToggleMarkL()
- {
- const TInt index( iContainer->ListBoxCurrentItemIndex() );
- if ( iEngine.IsFolder( index ) )
- {
- iContainer->ListBoxDeselectItem( index );
- }
- else
- {
- iContainer->ListBoxToggleItemL( index );
- }
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::CmdMarkAllL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::CmdMarkAllL()
- {
- iContainer->ListBoxSelectAllL();
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::CmdUnmarkAllL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::CmdUnmarkAllL()
- {
- iContainer->ListBoxClearSelection();
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::CmdRenameL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::CmdRenameL()
- {
- TInt index( iContainer->ListBoxCurrentItemIndex() );
- if ( index >= 0 )
- {
- StoreIndex();
- CFileManagerItemProperties* prop =
- iEngine.GetItemInfoL( index );
- CleanupStack::PushL( prop );
-
- if ( DriveReadOnlyMmcL( prop->FullPath() ) )
- {
- CleanupStack::PopAndDestroy( prop );
- return;
- }
-
- HBufC* itemNameBuf = HBufC::NewLC( KMaxFileName );
- TPtr itemName( itemNameBuf->Des() );
- itemName.Append( prop->NameAndExt() );
-
- TInt err( KErrNone );
- TBool ret( EFalse );
- if ( prop->TypeL() & CFileManagerItemProperties::EFolder )
- {
- DenyDirectoryRefresh( ETrue );
- TRAP( err, ret = FileManagerDlgUtils::ShowFolderNameQueryL(
- R_QTN_FLDR_ITEM_NAME_PRMPT, itemName, iEngine ) );
- DenyDirectoryRefresh( EFalse );
- User::LeaveIfError( err );
- if ( ret )
- {
- if ( itemName.Length() > 1 )
- {
- if ( itemName[0] == '.' )
- {
- TInt j = 1;
- for ( j; j < itemName.Length(); j++ )
- {
- if ( !( (itemName[j] <= 'Z') && (itemName[j] >= 'A') ) )
- {
- break;
- }
- }
- if ( j == itemName.Length() )
- {
- itemName.Delete(0, 1);
- }
- }
- }
- TRAP( err, iEngine.RenameL( index, itemName ) );
- if ( err == KErrAccessDenied ||
- err == KErrInUse ||
- err == KErrBadName ||
- err == KErrAlreadyExists ||
- err == KErrNotReady )
- {
- err = KErrNone; // Set error as handled
- FileManagerDlgUtils::ShowInfoNoteL(
- R_QTN_FLDR_CANT_RENAME_ITEM,
- prop->NameAndExt() );
- }
- }
- }
- else
- {
- DenyDirectoryRefresh( ETrue );
- TRAP( err, ret = FileManagerDlgUtils::ShowFileNameQueryL(
- R_QTN_FLDR_ITEM_NAME_PRMPT, prop->FullPath(), itemName, iEngine ) );
- DenyDirectoryRefresh( EFalse );
- User::LeaveIfError( err );
- if ( ret )
- {
- TRAP( err, iEngine.RenameL( index, itemName ) );
- if ( err == KErrAccessDenied ||
- err == KErrInUse ||
- err == KErrBadName ||
- err == KErrAlreadyExists ||
- err == KErrNotReady )
- {
- err = KErrNone; // Set error as handled
- FileManagerDlgUtils::ShowInfoNoteL(
- R_QTN_FLDR_CANT_RENAME_ITEM,
- prop->NameAndExt() );
- }
- }
- }
-
- CleanupStack::PopAndDestroy( itemNameBuf );
- CleanupStack::PopAndDestroy( prop );
- User::LeaveIfError( err );
- }
- iEngine.SetObserver( this );
- iEngine.RefreshDirectory();
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::CmdFindL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::CmdFindL()
- {
- HBufC* path = HBufC::NewLC( KMaxFileName );
- TPtr ptrPath( path->Des() );
- if( AskPathL( ptrPath, R_QTN_FMGR_FIND_PRTX ) )
- {
- HBufC* searchStringBuf = HBufC::NewLC( KMaxFileName );
- TPtr searchString( searchStringBuf->Des() );
- HBufC* prompt = StringLoader::LoadLC( R_QTN_FMGR_FIND_DATAQ_PRTX );
- CAknTextQueryDialog *textQuery =
- new( ELeave ) CAknTextQueryDialog( searchString, *prompt );
- if ( textQuery->ExecuteLD( R_FILEMANAGER_SEARCH_QUERY ) )
- {
- iEngine.SetSearchStringL( searchString );
- iEngine.SetSearchFolderL( ptrPath );
- if ( Id() == CFileManagerAppUi::KFileManagerSearchResultsViewId )
- {
- // Start new search in the existing view
- iIndex = 0;
- iEngine.SetObserver( this );
- iEngine.RefreshDirectory();
- }
- else
- {
- // Open search view and start new search
- StoreIndex();
- // Ensure that current directory is set correctly.
- // If current view was opened from previous search results view,
- // backstep stack to current directory may be incomplete.
- iEngine.SetDirectoryWithBackstepsL( iEngine.CurrentDirectory() );
- CFileManagerAppUi* appUi =
- static_cast< CFileManagerAppUi* >( AppUi() );
- appUi->ActivateSearchResultsViewL();
- }
- }
- CleanupStack::PopAndDestroy( prompt );
- CleanupStack::PopAndDestroy( searchStringBuf );
- }
- CleanupStack::PopAndDestroy( path );
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::CmdViewInfoL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::CmdViewInfoL()
- {
- TInt index( iContainer->ListBoxCurrentItemIndex() );
- if ( index >= 0 )
- {
- CFileManagerItemProperties* prop = iEngine.GetItemInfoL( index );
- CleanupStack::PushL( prop );
- FileManagerDlgUtils::ShowItemInfoPopupL( *prop, FeatureManager() );
- CleanupStack::PopAndDestroy( prop );
- }
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::CmdMemoryStateL
-//
-// -----------------------------------------------------------------------------
-//
-//void CFileManagerViewBase::CmdMemoryStateL()
-// {
-// TInt drv( iEngine.CurrentDrive() );
-// if ( drv != KErrNotFound )
-// {
-// HBufC* title = StringLoader::LoadLC( R_QTN_FMGR_MSTATE_HEADING );
-// CMemStatePopup::RunLD(
-// static_cast< TDriveNumber >( drv ), *title );
-// CleanupStack::PopAndDestroy( title );
-// }
-// }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::CmdReceiveViaIR
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::CmdReceiveViaIRL()
- {
-
- if ( DriveReadOnlyMmcL( iEngine.CurrentDirectory() ) )
- {
- return;
- }
-
- iEngine.SetObserver( this );
-
- ClearProgressBarL();
-
- iProgressDialog = new( ELeave ) CAknProgressDialog(
- reinterpret_cast< CEikDialog** >( &iProgressDialog ), ETrue );
- iProgressDialog->PrepareLC( R_FILE_RECEIVE_DIALOG );
- iProgressInfo = iProgressDialog->GetProgressInfoL();
- if ( iProgressInfo )
- {
- // final value is 100 percent
- iProgressInfo->SetFinalValue( KMaxPercentage );
- }
- iProgressDialog->RunLD();
- iProgressDialog->SetCallback( this );
-
- HBufC* label = StringLoader::LoadLC( R_QTN_IR_CONNECTING );
- iProgressDialog->SetTextL( *label );
- CleanupStack::PopAndDestroy( label );
-
- CFileManagerAppUi* appUi = static_cast< CFileManagerAppUi* >( AppUi() );
- TRAPD( err, appUi->StartIRReceiveL( *this ) );
-
- if ( err == KErrNone )
- {
- iActiveProcess = MFileManagerProcessObserver::EIRReceiveProcess;
- }
- else
- {
- ClearProgressBarL();
- User::Leave( err );
- }
- }
-
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::DynInitMenuPaneL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::DynInitMenuPaneL( TInt aResourceId,
- CEikMenuPane* aMenuPane)
- {
- TBool isHandled( ETrue );
-
- switch( aResourceId )
- {
- // These menus are used by memory store and folders views
- case R_FILEMANAGER_MEMORY_STORE_VIEW_MENU:
- {
- MemoryStoreMenuFilteringL( *aMenuPane );
- break;
- }
- case R_FILEMANAGER_MARK_UNMARK_MENU:
- case R_FILEMANAGER_CONTEXT_SENSITIVE_MARK_UNMARK_MENU:
- {
- MarkMenuFilteringL( *aMenuPane );
- break;
- }
- case R_FILEMANAGER_ORGANISE_MENU:
- {
- OrganiseMenuFilteringL( *aMenuPane );
- break;
- }
- case R_FILEMANAGER_DETAILS_MENU:
- {
- DetailsMenuFilteringL( *aMenuPane );
- break;
- }
-// case R_FILEMANAGER_MEMORY_CARD_MENU:
-// {
-// MemoryCardMenuFilteringL( *aMenuPane );
-// break;
-// }
-// case R_FILEMANAGER_MEMORY_CARD_PASSWORD_MENU:
-// {
-// MemoryCardPasswordMenuFilteringL( *aMenuPane );
-// break;
-// }
- case R_FILEMANAGER_CONTEXT_SENSITIVE_MENU:
- {
- ContextSensitiveMenuFilteringL( *aMenuPane );
- break;
- }
- case R_FILEMANAGER_SORT_MENU:
- case R_FILEMANAGER_SEARCH_SORT_MENU: // Fall through
- {
- SortMenuFilteringL( *aMenuPane );
- break;
- }
- default:
- {
- isHandled = EFalse;
- break;
- }
- }
-
- TBool isContextMenu( aResourceId == R_FILEMANAGER_CONTEXT_SENSITIVE_MENU );
- if ( isHandled || isContextMenu )
- {
- CEikMenuBar* menuBar = MenuBar();
- if ( menuBar )
- {
- if ( isContextMenu )
- {
- menuBar->SetMenuType( CEikMenuBar::EMenuContext );
- }
- else
- {
- menuBar->SetMenuType( CEikMenuBar::EMenuOptions );
- }
- }
- }
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::DoActivateL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::DoActivateL( const TVwsViewId& /*aPrevViewId*/,
- TUid /*aCustomMessageId*/,
- const TDesC8& /*aCustomMessage*/ )
- {
- if ( !iContainer )
- {
- iContainer = CreateContainerL();
- iContainer->SetMopParent( this );
- AppUi()->AddToStackL( *this, iContainer );
- iEngine.SetObserver( this );
- iContainer->ActivateL();
- }
-
- if ( iContainer )
- {
- iContainer->SetListEmptyL();
- }
-
- // Set container to observe MSK commands
- CEikButtonGroupContainer* bgc = Cba();
- if ( bgc )
- {
- CEikCba* cba = static_cast< CEikCba* >( bgc->ButtonGroup() );
- cba->SetMSKCommandObserver( iContainer );
- }
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::DoDeactivate
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::DoDeactivate()
- {
- if ( iContainer )
- {
- AppUi()->RemoveFromStack( iContainer );
- delete iContainer;
- iContainer = NULL;
- }
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::MarkedArrayLC
-//
-// -----------------------------------------------------------------------------
-//
-CArrayFixFlat<TInt>* CFileManagerViewBase::MarkedArrayLC()
- {
- TInt count( iContainer->ListBoxSelectionIndexesCount() );
- CArrayFixFlat<TInt>* ret =
- new( ELeave ) CArrayFixFlat<TInt>( count ? count : 1 );
-
- CleanupStack::PushL( ret );
-
- if ( !count )
- {
- if ( iContainer->ListBoxNumberOfItems() > 0)
- {
- ret->AppendL( iContainer->ListBoxCurrentItemIndex() );
- }
- return ret;
- }
-
- const CArrayFix< TInt >* items = iContainer->ListBoxSelectionIndexes();
- for( TInt i( 0 ); i < count; ++i )
- {
- ret->AppendL( items->At( i ) );
- }
- return ret;
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::DialogDismissedL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::DialogDismissedL( TInt aButtonId )
- {
- FUNC_LOG
-
- if ( aButtonId == EAknSoftkeyCancel )
- {
- TBool isHandled( ETrue );
- switch( iActiveProcess )
- {
- case ENoProcess:
- {
- if ( IsRefreshInProgress() )
- {
- // Already freed, just set to NULL
- iProgressDialogRefresh = NULL;
- iEngine.CancelRefresh();
- DirectoryChangedL(); // Ensure that view gets updated
- }
- break;
- }
- case EIRReceiveProcess:
- {
- // Already freed, just set to NULL
- iProgressDialog = NULL;
- iProgressInfo = NULL;
-
- static_cast< CFileManagerAppUi* >( AppUi() )->StopIRReceive();
- break;
- }
- case ECopyProcess: // FALLTHROUGH
- case EMoveProcess:
- {
- // Already freed, just set to NULL
- iProgressDialog = NULL;
- iProgressInfo = NULL;
-
- delete iPeriodic;
- iPeriodic = NULL;
- if ( iActiveExec )
- {
- iActiveExec->CancelExecution();
- }
- break;
- }
- case EFileOpenProcess: // FALLTHROUGH
- case EBackupProcess: // FALLTHROUGH
- case ERestoreProcess:
- {
- // Already freed, just set to NULL
- iProgressDialog = NULL;
- iProgressInfo = NULL;
-
- iEngine.CancelProcess( iActiveProcess );
- if ( iActiveProcess == EBackupProcess ||
- iActiveProcess == ERestoreProcess )
- {
- CFileManagerAppUi* appUi = static_cast< CFileManagerAppUi* >( AppUi() );
- appUi->BackupOrRestoreEnded();
- }
- break;
- }
- case EFormatProcess: // FALLTHROUGH
- case EEjectProcess:
- {
- // Already freed, just set to NULL
- iProgressDialog = NULL;
- iProgressInfo = NULL;
- break;
- }
- default:
- {
- isHandled = EFalse;
- break;
- }
- }
- if ( isHandled )
- {
- iEikonEnv->SetSystem( EFalse );
- iActiveProcess = ENoProcess;
- }
-
-#ifdef RD_FILE_MANAGER_BACKUP
- if ( iSchBackupPending )
- {
- StartSchBackupL();
- }
-#endif // RD_FILE_MANAGER_BACKUP
-
- }
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::ProcessFinishedL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::ProcessFinishedL( TInt aError, const TDesC& aName )
- {
- FUNC_LOG
-
- TRAPD( err, DoProcessFinishedL( aError, aName ) );
- if( err != KErrNone )
- {
- // Clean up the active process before forwarding leave
- ERROR_LOG2(
- "CFileManagerViewBase::ProcessFinishedL-iActiveProcess=%d,err=%d",
- iActiveProcess, err )
- iEikonEnv->SetSystem( EFalse );
- iActiveProcess = ENoProcess;
- User::Leave( err );
- }
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::DoProcessFinishedL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::DoProcessFinishedL( TInt aError, const TDesC& aName )
- {
- FUNC_LOG
-
- TBool isHandled( ETrue );
- TBool doRefresh( ETrue );
-
- LOG_IF_ERROR2( aError, "CFileManagerViewBase::DoProcessFinishedL-iActiveProcess=%d,aError=%d",
- iActiveProcess, aError )
-
- if ( iPeriodic && iProgressInfo && iTotalTransferredBytes )
- {
- iProgressInfo->SetAndDraw( iTotalTransferredBytes );
- }
- if ( IsSystemProcess( iActiveProcess ) )
- {
- // Remove system status to allow app close from task switcher
- iEikonEnv->SetSystem( EFalse );
- }
-
- ClearProgressBarL();
-
- switch( iActiveProcess )
- {
- case EIRReceiveProcess: // FALLTHROUGH
- {
- static_cast< CFileManagerAppUi* >( AppUi() )->StopIRReceive();
- if ( aError != KErrNone && aError != KErrCancel )
- {
- if ( aError == KErrDiskFull )
- {
- ShowDiskSpaceErrorL( iEngine.CurrentDirectory() );
- }
- else
- {
- // Show general error note
- Error( aError );
- }
- }
- break;
- }
- case ECopyProcess: // FALLTHROUGH
- case EMoveProcess:
- {
- if ( aError != KErrNone && aError != KErrCancel && !aName.Length() )
- {
- // Show general error note if item name is unavailable
- if ( iActiveExec && aError == KErrDiskFull )
- {
- ShowDiskSpaceErrorL( iActiveExec->ToFolder() );
- }
- else
- {
- Error( aError );
- }
- }
- else if ( aError != KErrNone )
- {
- // If the copy process is cancelled, no error notes should be displayed
- if( aError != KErrCancel )
- {
- // Show more informative note first
- if ( iActiveExec && aError == KErrDiskFull )
- {
- ShowDiskSpaceErrorL( iActiveExec->ToFolder() );
- }
- else if ( aError == KErrNoMemory ||
- aError == KErrDiskFull ||
- aError == KErrDirFull )
- {
- Error( aError );
- }
- if ( iActiveProcess == EMoveProcess )
- {
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_FLDR_ITEM_CANNOT_BE_MOVED, aName );
- }
- else
- {
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_FLDR_ITEM_CANNOT_BE_COPIED, aName );
- }
- }
- delete iActiveExec;
- iActiveExec = NULL;
- }
- else if ( iActiveProcess == EMoveProcess && iMarkedArray )
- {
- // Set focus to the item after selection
- TInt newIndex( MinIndex( *iMarkedArray ) );
- if ( iContainer )
- {
- iContainer->SetIndex( newIndex );
- }
- StoreIndex();
- }
-
- break;
- }
- case EFileOpenProcess:
- {
- if ( aError != KErrNone && aError != KErrCancel )
- {
- if ( aError == KErrNoMemory || aError == KErrDiskFull )
- {
- Error( aError );
- }
- else if ( aError == KErrNotSupported )
- {
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_FMGR_ERROR_UNSUPPORT );
- }
- else if ( aError == KErrFmgrNotSupportedRemotely )
- {
- FileManagerDlgUtils::ShowConfirmQueryWithOkL(
- FileManagerDlgUtils::EInfoIcons,
- R_QTN_FMGR_INFONOTE_UNABLE_OPEN_REMOTELY );
- }
- else if ( !HandleFileNotFoundL( aError ) )
- {
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_FMGR_ERROR_CANT_OPEN );
- }
- }
- else
- {
- // No refresh needed if open was successful or canceled
- doRefresh = EFalse;
- }
- break;
- }
- case EFormatProcess:
- {
- TFileManagerDriveInfo drvInfo;
- DriveInfoAtCurrentPosL( drvInfo );
- if ( aError == KErrNone )
- {
-#ifdef RD_MULTIPLE_DRIVE
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveMassStorage )
- {
- FileManagerDlgUtils::ShowInfoNoteL(
- R_QTN_FMGR_MASS_FORMAT_COMPLETED );
- }
- else
- {
-#endif // RD_MULTIPLE_DRIVE
- FileManagerDlgUtils::ShowInfoNoteL( R_QTN_FORMAT_COMPLETED );
-
- // After formatting a name to the card can be given
- RenameDriveL( ETrue );
-#ifdef RD_MULTIPLE_DRIVE
- }
-#endif // RD_MULTIPLE_DRIVE
- }
- else if ( aError == KErrInUse || aError > 0 )
- {
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_FORMAT_FILES_IN_USE );
- }
- else if ( aError != KErrCancel )
- {
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_CRITICAL_ERROR );
- }
- break;
- }
- case EBackupProcess:
- {
- CFileManagerAppUi* appUi = static_cast< CFileManagerAppUi* >( AppUi() );
- appUi->BackupOrRestoreEnded();
- if ( aError == KErrNone )
- {
- FileManagerDlgUtils::ShowInfoNoteL(
- R_QTN_BACKUP_COMPLETED );
- }
- else if ( aError == KErrDiskFull )
- {
-#ifdef RD_FILE_MANAGER_BACKUP
-
- CFileManagerBackupSettings& settings(
- iEngine.BackupSettingsL() );
-
- FileManagerDlgUtils::ShowConfirmQueryWithOkL(
- FileManagerDlgUtils::EErrorIcons,
- R_QTN_FMGR_BACKUP_DESTINATION_FULL,
- iEngine.DriveName( settings.TargetDrive() ) );
-
-#else // RD_FILE_MANAGER_BACKUP
-
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_BACKUP_NO_SPACE );
-
-#endif // RD_FILE_MANAGER_BACKUP
- }
- else if ( aError > 0 )
- {
- // No critical error, but some files not handled
- if ( aError > 1 )
- {
- FileManagerDlgUtils::ShowConfirmQueryWithOkL(
- FileManagerDlgUtils::EInfoIcons,
- R_QTN_FILES_NOT_BACKUPPED,
- aError );
- }
- else
- {
- FileManagerDlgUtils::ShowConfirmQueryWithOkL(
- FileManagerDlgUtils::EInfoIcons,
- R_QTN_ONE_FILE_NOT_BACKUPPED );
- }
- }
- else if ( aError != KErrCancel )
- {
- if ( aError == KErrNoMemory || aError == KErrDirFull )
- {
- // Show more informative note first
- Error( aError );
- }
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_CRITICAL_ERROR );
- }
- break;
- }
- case ERestoreProcess:
- {
- CFileManagerAppUi* appUi = static_cast< CFileManagerAppUi* >( AppUi() );
- appUi->BackupOrRestoreEnded();
- if ( aError == KErrNone )
- {
- FileManagerDlgUtils::ShowInfoNoteL(
- R_QTN_RESTORE_COMPLETED );
- }
- else if ( aError == KErrDiskFull )
- {
- FileManagerDlgUtils::ShowErrorNoteL(
-#ifdef RD_FILE_MANAGER_BACKUP
- R_QTN_FMGR_RESTORE_SPACE_ERROR
-#else // RD_FILE_MANAGER_BACKUP
- R_QTN_RESTORE_NO_SPACE
-#endif // RD_FILE_MANAGER_BACKUP
- );
- }
-#ifdef RD_FILE_MANAGER_BACKUP
- else if ( aError == KErrCorrupt )
- {
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_FMGR_ERROR_CORRUPTED_BACKUP_FILE );
- }
-#endif // RD_FILE_MANAGER_BACKUP
- else if ( aError > 0 )
- {
- // No critical error, but some files not handled
- if ( aError > 1 )
- {
- FileManagerDlgUtils::ShowInfoNoteL(
- R_QTN_FILES_NOT_RESTORED, aError );
- }
- else
- {
- FileManagerDlgUtils::ShowInfoNoteL(
- R_QTN_ONE_FILE_NOT_RESTORED );
- }
- }
- else
- {
- if ( aError == KErrNoMemory || aError == KErrDirFull )
- {
- // Show more informative note first
- Error( aError );
- }
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_CRITICAL_ERROR );
- }
- break;
- }
- case EEjectProcess:
- {
- TRAP_IGNORE( ShowEjectQueryL() );
- break;
- }
-#ifdef RD_FILE_MANAGER_BACKUP
- case ESchBackupProcess:
- {
- CFileManagerAppUi* appUi =
- static_cast< CFileManagerAppUi* >( AppUi() );
- appUi->SchBackupHandlerL().ProcessFinishedL( aError, aName );
- // No refresh needed, done by view activation
- doRefresh = EFalse;
- break;
- }
-#endif // RD_FILE_MANAGER_BACKUP
- default:
- {
- isHandled = EFalse;
- break;
- }
- }
-
- if ( isHandled )
- {
- iEikonEnv->SetSystem( EFalse );
- iActiveProcess = ENoProcess;
-
- if ( doRefresh )
- {
- iEngine.SetObserver( this );
- iEngine.RefreshDirectory();
- }
- }
-
-#ifdef RD_FILE_MANAGER_BACKUP
- if ( iSchBackupPending )
- {
- StartSchBackupL();
- }
-#endif // RD_FILE_MANAGER_BACKUP
-
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::ProcessAdvanceL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::ProcessAdvanceL( TInt aValue )
- {
- FUNC_LOG
-
- switch( iActiveProcess )
- {
- case EIRReceiveProcess:
- {
- if ( iProgressDialog )
- {
- HBufC* label = StringLoader::LoadLC(
- R_QTN_FMGR_NOTE_RECEIVE_IR, aValue );
- iProgressDialog->SetTextL( *label );
- CleanupStack::PopAndDestroy( label );
- // Incrementing progress of the process:
- if ( iProgressInfo )
- {
- iProgressInfo->SetAndDraw( aValue );
- }
- }
- break;
- }
- case EBackupProcess: // FALLTHROUGH
- case ERestoreProcess: // FALLTHROUGH
- case EFormatProcess:
- {
-#ifdef RD_FILE_MANAGER_BACKUP
- if ( iActiveProcess == EBackupProcess && iProgressDialog )
- {
- HBufC* label = StringLoader::LoadLC(
- R_QTN_BACKUP_INPROGRESS );
- iProgressDialog->SetTextL( *label );
- CleanupStack::PopAndDestroy( label );
-
- iProgressDialog->ButtonGroupContainer().SetCommandSetL(R_AVKON_SOFTKEYS_CANCEL);
- iProgressDialog->ButtonGroupContainer().DrawDeferred();
- }
- else if ( iActiveProcess == ERestoreProcess && iProgressDialog )
- {
- HBufC* label = StringLoader::LoadLC(
- R_QTN_RESTORE_INPROGRESS );
- iProgressDialog->SetTextL( *label );
- CleanupStack::PopAndDestroy( label );
- }
-#endif // RD_FILE_MANAGER_BACKUP
- if ( iProgressInfo )
- {
- iProgressInfo->SetAndDraw( aValue );
- }
- break;
- }
-#ifdef RD_FILE_MANAGER_BACKUP
- case ESchBackupProcess:
- {
- CFileManagerAppUi* appUi =
- static_cast< CFileManagerAppUi* >( AppUi() );
- appUi->SchBackupHandlerL().ProcessAdvanceL( aValue );
- break;
- }
-#endif // RD_FILE_MANAGER_BACKUP
- default:
- {
- break;
- }
- }
- iTotalTransferredBytes = static_cast<TUint>(aValue); // to avoid over 2GB files looks likes minus value
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::ProcessStartedL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::ProcessStartedL(
- MFileManagerProcessObserver::TFileManagerProcess aProcess,
- TInt aFinalValue )
- {
- FUNC_LOG
-
- // For preventing shutter to close app during system process
- iEikonEnv->SetSystem( IsSystemProcess( aProcess ) );
-
- switch( aProcess )
- {
- case EIRReceiveProcess:
- {
- if ( iProgressDialog )
- {
- HBufC* label = StringLoader::LoadLC(
- R_QTN_FMGR_NOTE_RECEIVE_IR, 0 );
- iProgressDialog->SetTextL( *label );
- CleanupStack::PopAndDestroy( label );
- }
- break;
- }
- case EFileOpenProcess:
- {
- ClearProgressBarL();
- LaunchProgressDialogL( 0, 0, aProcess );
- iActiveProcess = aProcess;
- break;
- }
- case ERestoreProcess:
- {
- CEikButtonGroupContainer* cba = Cba();
- cba->SetCommandSetL( R_AVKON_SOFTKEYS_EMPTY );
- cba->DrawDeferred();
- // FALLTHROUGH
- }
- case EBackupProcess: // FALLTHROUGH
- case EFormatProcess:
- {
- if ( iProgressDialog )
- {
- if ( !iProgressDialog->IsVisible() )
- {
- iProgressDialog->MakeVisible( ETrue );
- }
- }
- if ( iProgressInfo )
- {
- iProgressInfo->SetFinalValue( aFinalValue );
- }
- break;
- }
-#ifdef RD_FILE_MANAGER_BACKUP
- case ESchBackupProcess:
- {
- CFileManagerAppUi* appUi =
- static_cast< CFileManagerAppUi* >( AppUi() );
- appUi->SchBackupHandlerL().ProcessStartedL( aFinalValue );
- break;
- }
-#endif // RD_FILE_MANAGER_BACKUP
- default:
- {
- break;
- }
- }
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::RunOperationL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::RunOperationL
- ( MFileManagerProcessObserver::TFileManagerProcess aOperation,
- const TDesC& aToFolder )
- {
-
- StoreIndex();
- delete iMarkedArray;
- iMarkedArray = NULL;
- iMarkedArray = MarkedArrayLC();
- CleanupStack::Pop( iMarkedArray );
-
- // Check if marked source and destination folder are available
- if ( !iMarkedArray->Count() || !IsDriveAvailable( aToFolder ) )
- {
- return;
- }
-
- CFileManagerItemProperties* prop =
- iEngine.GetItemInfoLC( iMarkedArray->At( 0 ) );
-
-#ifdef __KEEP_DRM_CONTENT_ON_PHONE
- // When this flag is on all the selected items have to be gone through and checked
- // whether they are protected and the user has to be notified when moving or
- // copying file(s) is impossible. This only applies to processes from phone to MMC.
- TBool process( ETrue );
- if ( CFileManagerUtils::IsFromInternalToRemovableDrive(
- iEikonEnv->FsSession(), iEngine.CurrentDirectory(), aToFolder ) )
- {
- TInt fileAmount (iMarkedArray->Count());
-
- // Only one folder can be selected at a time
- if (iEngine.IsFolder(iMarkedArray->At( 0 )))
- {
- if ( prop->FilesContainedL() == 0 && prop->FoldersContainedL() == 0)
- {
- process = ETrue;
- }
- else if (AreChosenFilesProtectedL( ETrue ))
- {
- if ( aOperation == EMoveProcess )
- {
- FileManagerDlgUtils::ShowInfoNoteL(
- R_QTN_DRM_INFO_MOVE_FOLDER_FORBID );
- }
- else
- {
- FileManagerDlgUtils::ShowInfoNoteL(
- R_QTN_DRM_INFO_COPY_FOLDER_FORBID );
- }
- process = EFalse;
- }
- else if (AreChosenFilesProtectedL( EFalse ))
- {
- TInt textId( 0 );
- if ( aOperation == EMoveProcess )
- {
- textId = R_QTN_DRM_QUERY_MOVE_FORBIDDEN;
- }
- else
- {
- textId = R_QTN_DRM_QUERY_COPY_FORBIDDEN;
- }
- if ( FileManagerDlgUtils::ShowConfirmQueryWithYesNoL(
- textId ) )
- {
- // Engine will not touch protected objects anyway
- process = ETrue;
- }
- else
- {
- process = EFalse;
- }
- }
- }
- else if ( fileAmount == 1 && AreChosenFilesProtectedL( ETrue ))
- {
- if ( aOperation == EMoveProcess )
- {
- FileManagerDlgUtils::ShowInfoNoteL(
- R_QTN_DRM_INFO_MOVE_ONE_FORBID );
- }
- else
- {
- FileManagerDlgUtils::ShowInfoNoteL(
- R_QTN_DRM_INFO_COPY_ONE_FORBID );
- }
- process= EFalse;
- }
- else if ( fileAmount > 1 && AreChosenFilesProtectedL( EFalse ))
- {
- if (AreChosenFilesProtectedL( ETrue ))
- {
- if ( aOperation == EMoveProcess )
- {
- FileManagerDlgUtils::ShowInfoNoteL(
- R_QTN_DRM_INFO_MOVE_MANY_FORBID );
- }
- else
- {
- FileManagerDlgUtils::ShowInfoNoteL(
- R_QTN_DRM_INFO_COPY_MANY_FORBID );
- }
- process= EFalse;
- }
- else
- {
- TInt textId( 0 );
- if ( aOperation == EMoveProcess )
- {
- textId = R_QTN_DRM_QUERY_MOVE_FORBIDDEN;
- }
- else
- {
- textId = R_QTN_DRM_QUERY_COPY_FORBIDDEN;
- }
- if ( FileManagerDlgUtils::ShowConfirmQueryWithYesNoL(
- textId ) )
- {
- // Engine will not touch protected objects anyway
- process = ETrue;
- }
- else
- {
- process = EFalse;
- }
- }
- }
- }
- if ( process )
- {
-#endif // __KEEP_DRM_CONTENT_ON_PHONE
-
- TInt64 size( 0 );
- // Skip remote folder size counting because it may last very long time.
- // The content may also change during the operation what makes
- // the counting needless.
- if ( !( prop->IsRemoteDrive() &&
- ( prop->TypeL() & CFileManagerItemProperties::EFolder ) ) )
- {
- size = iEngine.GetFileSizesL( *iMarkedArray ) ;
- }
- if ( size == KErrNotFound )
- {
- // User has cancelled size calculation, do nothing
- }
- else if ( iEngine.EnoughSpaceL( aToFolder, size, aOperation ))
- {
- iTotalTransferredBytes = 0;
- iEngine.SetObserver( this );
- if ( aOperation == EMoveProcess &&
- aToFolder.Left( KDriveLetterSize ) ==
- prop->FullPath().Left( KDriveLetterSize ) )
- {
- // If operation is move and it happens inside drive
- // set size to file amount
- // CFileMan is not calling notify if those conditions apply
- if ( iMarkedArray->Count() > 0 )
- {
- size = iMarkedArray->Count();
- }
- else
- {
- // Folder move time we cannot predict, so setting size to
- // 0 to show wait note, one file moves so fast that it
- // won't show wait note anyway
- size = 0;
- }
- }
-
- if ( prop->IsRemoteDrive() ||
- CFileManagerUtils::IsRemoteDrive(
- iEikonEnv->FsSession(), aToFolder ) )
- {
- // Use wait note for remote drives
- // because real progress information is unavailable
- size = 0;
- }
-
- LaunchProgressDialogL( size, 0, aOperation );
- delete iActiveExec;
- iActiveExec = NULL;
- iActiveExec = CFileManagerActiveExecute::NewL(
- iEngine, aOperation, *this, *iMarkedArray, aToFolder );
- iActiveProcess = aOperation;
- TRAPD( err, iActiveExec->ExecuteL( CFileManagerActiveExecute::ENoOverWrite ) );
- if ( err != KErrNone )
- {
- // Clean up the active process before forwarding leave
- ERROR_LOG2(
- "CFileManagerViewBase::RunOperationL-aOperation=%d,err=%d",
- aOperation, err )
- iActiveProcess = ENoProcess;
- User::Leave( err );
- }
- }
- else
- {
- ShowDiskSpaceErrorL( aToFolder );
- }
-
-#ifdef __KEEP_DRM_CONTENT_ON_PHONE
- }
-#endif // __KEEP_DRM_CONTENT_ON_PHONE
-
- CleanupStack::PopAndDestroy( prop );
-
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::ProcessQueryOverWriteL
-//
-// -----------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::ProcessQueryOverWriteL
- ( const TDesC& aOldName, TDes& aNewName, TFileManagerProcess aOperation )
- {
-
- TParsePtrC name( aOldName );
-
- // Stop progress note before showing the query to be restarted later.
- // Note that progress note may still exist after stop (to fill min time on screen)
- // and it gets deleted later by AVKON. Asynchronous restart is needed to prevent
- // mess up (if note still exists). Otherwise starting and stopping progress note too
- // quickly multiple times leads to mess up in AVKON's note handling.
- StopProgressDialogAndStoreValues();
-
- TBool overWrite( FileManagerDlgUtils::ShowConfirmQueryWithYesNoL(
- R_QTN_FLDR_OVERWRITE_QUERY, name.NameAndExt() ) );
- if ( !overWrite )
- {
- if ( !FileManagerDlgUtils::ShowFileNameQueryL(
- R_QTN_FLDR_ITEM_NAME_PRMPT, aOldName, aNewName, iEngine ) )
- {
- aNewName.Zero();
- }
- }
-
- if ( iActiveProcess == aOperation &&
- ( aOperation == MFileManagerProcessObserver::ECopyProcess ||
- aOperation == MFileManagerProcessObserver::EMoveProcess ) )
- {
- // Progress note needs asynchronous start because of AVKON's note handling.
- delete iRefreshProgressDelayedStart;
- iRefreshProgressDelayedStart = NULL;
- iRefreshProgressDelayedStart = CPeriodic::NewL( CActive::EPriorityUserInput );
- iRefreshProgressDelayedStart->Start(
- KProgressBarAsyncStartDelay, KProgressBarAsyncStartDelay,
- TCallBack( LaunchProgressDialogAsync, this ) );
- }
-
- return overWrite;
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::ProcessQueryRenameL
-//
-// -----------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::ProcessQueryRenameL
- ( const TDesC& aOldName, TDes& aNewName, TFileManagerProcess aOperation )
- {
- TParsePtrC typeCheck( aOldName );
- TParse oldName;
- TBool folderRename( EFalse );
-
- // Check is item file or folder
- if ( !typeCheck.NameOrExtPresent() )
- {
- oldName.Set( aOldName.Left( aOldName.Length() - 1 ), NULL, NULL );
- folderRename = ETrue;
- }
- else
- {
- oldName.Set( aOldName , NULL, NULL );
- }
-
- // Stop progress note before showing the query to be restarted later.
- // Note that progress note may still exist after stop (to fill min time on screen)
- // and it gets deleted later by AVKON. Asynchronous restart is needed to prevent
- // mess up (if note still exists). Otherwise starting and stopping progress note too
- // quickly multiple times leads to mess up in AVKON's note handling.
- StopProgressDialogAndStoreValues();
-
- TBool rename( FileManagerDlgUtils::ShowConfirmQueryWithOkCancelL(
- R_QTN_FLDR_RENAME_QUERY, oldName.NameAndExt() ) );
- if ( rename )
- {
- TBool done( 0 );
- if ( folderRename )
- {
- aNewName.Copy( aOldName );
- done = FileManagerDlgUtils::ShowFolderNameQueryL(
- R_QTN_FLDR_ITEM_NAME_PRMPT, aNewName, iEngine );
- }
- else
- {
- done = FileManagerDlgUtils::ShowFileNameQueryL(
- R_QTN_FLDR_ITEM_NAME_PRMPT, aOldName, aNewName, iEngine );
- }
-
- if ( !done )
- {
- // User cancelled rename
- aNewName.Zero();
- }
- else
- {
- //file server doesn't support the space in the end of the folder/file name
- aNewName.TrimRight();
- }
- }
-
- if ( iActiveProcess == aOperation &&
- ( aOperation == MFileManagerProcessObserver::ECopyProcess ||
- aOperation == MFileManagerProcessObserver::EMoveProcess ) )
- {
- // Progress note needs asynchronous start because of AVKON's note handling.
- delete iRefreshProgressDelayedStart;
- iRefreshProgressDelayedStart = NULL;
- iRefreshProgressDelayedStart = CPeriodic::NewL( CActive::EPriorityUserInput );
- iRefreshProgressDelayedStart->Start(
- KProgressBarAsyncStartDelay, KProgressBarAsyncStartDelay,
- TCallBack( LaunchProgressDialogAsync, this ) );
- }
-
- return rename;
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::LaunchProgressDialogL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::LaunchProgressDialogL(
- TInt64 aFinalValue,
- TInt64 aInitialValue,
- MFileManagerProcessObserver::TFileManagerProcess aOperation,
- TBool aImmediatelyVisible )
- {
- TInt dialogId( 0 );
- TInt textId( 0 );
- TBool isPeriodic( EFalse );
- TInt value;
- value=Int64ToInt(aFinalValue);
- switch ( aOperation )
- {
- case ECopyProcess:
- {
- isPeriodic = ( value > 1 );
- if ( isPeriodic )
- {
- dialogId = R_FILEMANAGER_PROGRESS_NOTE_COPY;
- }
- else
- {
- dialogId = R_FILEMANAGER_WAIT_NOTE_COPY;
- }
- break;
- }
- case EMoveProcess:
- {
- isPeriodic = ( value > 1 );
- if ( isPeriodic )
- {
- dialogId = R_FILEMANAGER_PROGRESS_NOTE_MOVE;
- }
- else
- {
- dialogId = R_FILEMANAGER_WAIT_NOTE_MOVE;
- }
- break;
- }
- case EFormatProcess:
- {
- dialogId = R_FILEMANAGER_PROGRESS_NOTE;
- TFileManagerDriveInfo drvInfo;
- DriveInfoAtCurrentPosL( drvInfo );
-#ifdef RD_MULTIPLE_DRIVE
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveMassStorage
- || drvInfo.iState & TFileManagerDriveInfo::EDriveUsbMemory )
- {
- textId = R_QTN_FMGR_MASS_FORMAT_INPROGRESS;
- }
- else
- {
-#endif // RD_MULTIPLE_DRIVE
- textId = R_QTN_FORMAT_INPROGRESS;
-#ifdef RD_MULTIPLE_DRIVE
- }
-#endif // RD_MULTIPLE_DRIVE
- break;
- }
- case EBackupProcess:
- {
- dialogId = R_FILEMANAGER_PROGRESS_NOTE_WITH_CANCEL;
-#ifdef RD_FILE_MANAGER_BACKUP
- textId = R_QTN_FMGR_PROGRESS_PREPARING_BACKUP;
-#else // RD_FILE_MANAGER_BACKUP
- textId = R_QTN_BACKUP_INPROGRESS;
-#endif // RD_FILE_MANAGER_BACKUP
- aImmediatelyVisible = ETrue;
- break;
- }
- case ERestoreProcess:
- {
- dialogId = R_FILEMANAGER_PROGRESS_NOTE;
-#ifdef RD_FILE_MANAGER_BACKUP
- textId = R_QTN_FMGR_PROGRESS_PREPARING_RESTORE;
-#else // RD_FILE_MANAGER_BACKUP
- textId = R_QTN_RESTORE_INPROGRESS;
-#endif // RD_FILE_MANAGER_BACKUP
- break;
- }
- case EEjectProcess:
- {
- dialogId = R_FILEMANAGER_WAIT_NOTE;
- textId = R_QTN_WAIT_EJECT;
- break;
- }
- case EFileOpenProcess:
- {
- dialogId = R_FILEMANAGER_WAIT_NOTE_OPEN_WITH_CANCEL;
- break;
- }
- default:
- {
- dialogId = R_FILEMANAGER_WAIT_NOTE_OPEN;
- break;
- }
- }
- LaunchProgressBarL(
- dialogId, textId, aFinalValue, aInitialValue, isPeriodic, aImmediatelyVisible );
-
-#ifdef RD_FILE_MANAGER_BACKUP
- if ( aOperation == EBackupProcess && iProgressDialog )
- {
- iProgressDialog->ButtonGroupContainer().SetCommandSetL(R_AVKON_SOFTKEYS_EMPTY);
- iProgressDialog->ButtonGroupContainer().DrawDeferred();
- }
-#endif // RD_FILE_MANAGER_BACKUP
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::ShowWaitDialogL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::ShowWaitDialogL( MAknBackgroundProcess& aProcess)
- {
- CAknWaitNoteWrapper* waitNoteWrapper = CAknWaitNoteWrapper::NewL();
- CleanupDeletePushL( waitNoteWrapper );
- waitNoteWrapper->ExecuteL( R_FILEMANAGER_WAIT_NOTE_PROCESS, aProcess );
- CleanupStack::PopAndDestroy( waitNoteWrapper );
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::DoUpdateProgressBar
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::DoUpdateProgressBar()
- {
- // Update progress indicator
- if ( iProgressDialog && iProgressInfo )
- {
- iProgressInfo->SetAndDraw( iTotalTransferredBytes / KMinificationFactor );
- }
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::UpdateProgressBar
-//
-// ------------------------------------------------------------------------------
-//
-TInt CFileManagerViewBase::UpdateProgressBar(TAny* aPtr )
- {
- static_cast< CFileManagerViewBase* >( aPtr )->DoUpdateProgressBar();
- return KErrNone;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::RefreshStartedL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::RefreshStartedL()
- {
- FUNC_LOG
-
- DenyDirectoryRefresh( EFalse );
-
- if ( static_cast< CFileManagerAppUi* >( AppUi() )->IsFmgrForeGround() )
- {
- if ( iContainer )
- {
- iContainer->SetListEmptyL();
- }
-
- ClearProgressBarL();
- if ( Id() == CFileManagerAppUi::KFileManagerSearchResultsViewId )
- {
- // On remote drives local find progress note is sometimes
- // totally blocked if the note is not started directly here.
- iProgressDialogRefresh = new( ELeave ) CAknProgressDialog(
- reinterpret_cast< CEikDialog** >(
- &iProgressDialogRefresh ), EFalse );
- iProgressDialogRefresh->SetCallback( this );
- iProgressDialogRefresh->ExecuteLD( R_FILEMANAGER_FIND_WAIT_DIALOG );
- }
- else
- {
- // Start progress dialog using own timer, otherwise progress dialog
- // burns sometimes quite a lot CPU time even if it is not
- // visible at all.
- iRefreshProgressDelayedStart = CPeriodic::NewL(
- CActive::EPriorityUserInput );
- iRefreshProgressDelayedStart->Start(
- KRefreshProgressStartDelay,
- KRefreshProgressStartDelay,
- TCallBack( RefreshProgressDelayedStart, this ) );
- }
- }
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::RefreshStoppedL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::RefreshStoppedL()
- {
- FUNC_LOG
-
- ClearProgressBarL();
-
- if( iContainer )
- {
- TInt index( iContainer->ListBoxCurrentItemIndex() );
- if ( index > 0 && index < iContainer->ListBoxNumberOfItems() )
- {
- iIndex = index;
- }
- DirectoryChangedL();
- UpdateCbaL();
- }
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::AreChosenFilesProtectedL
-//
-// ------------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::AreChosenFilesProtectedL( TBool aMode )
- {
- TBool ret = aMode;
- CArrayFixFlat<TInt>* indexArray = MarkedArrayLC();
-
- TInt i( 0 );
-
-#ifdef __KEEP_DRM_CONTENT_ON_PHONE
- TBool protectedFile( EFalse );
-#endif // __KEEP_DRM_CONTENT_ON_PHONE
-
- while( ( ret == aMode ) && i < indexArray->Count() )
- {
- CFileManagerItemProperties* prop = iEngine.GetItemInfoL( indexArray->At( i ));
- CleanupStack::PushL( prop );
-
-#ifdef __KEEP_DRM_CONTENT_ON_PHONE
- // Only one folder can be selected at a time
- if (iEngine.IsFolder(indexArray->At( i )))
- {
-
- CDirScan *dirScan = CDirScan::NewLC( iEikonEnv->FsSession() );
- CDir *currentDir = NULL;
- // Go through the files only
- dirScan->SetScanDataL( prop->FullPath(), KEntryAttNormal, ESortNone );
-
- dirScan->NextL( currentDir );
- while ( ( ret == aMode ) && currentDir )
- {
- CleanupStack::PushL( currentDir ); // currentDir won't be null
- // due to while loop conditional
- TInt j( 0 );
- while ( ( ret == aMode ) && j < currentDir->Count() )
- {
- const TEntry ¤tFile( ( *currentDir )[ j ] );
- TPtrC currentPath (dirScan->FullPath());
- HBufC* currentFilePath = HBufC::NewLC( KMaxFileName );
- TPtr completeFilePath = currentFilePath->Des();
- completeFilePath.Append(currentPath);
- completeFilePath.Append(currentFile.iName);
-
-
- // the following could leave if file is opened in exclusive
- // mode by another app- will cause 'in use' error dialog
- //to be displayed
- User::LeaveIfError( iEngine.IsDistributableFile( completeFilePath,
- protectedFile ));
- if( protectedFile == !aMode )
- {
- ret = !aMode;
- }
- ++j;
- CleanupStack::PopAndDestroy( currentFilePath );
- currentFilePath = NULL;
- }
- CleanupStack::PopAndDestroy( currentDir );
- currentDir=NULL;
- dirScan->NextL( currentDir );
- }
- CleanupStack::PopAndDestroy( dirScan );
- dirScan = NULL;
- }
- else
- {
-
- // the following could leave if file is opened in exclusive
- // mode by another app- will cause 'in use' error dialog
- //to be displayed
- User::LeaveIfError( iEngine.IsDistributableFile( prop->FullPath(),
- protectedFile ));
- if( protectedFile == !aMode )
- {
- ret = !aMode;
- }
- }
-
-#else // __KEEP_DRM_CONTENT_ON_PHONE
- if ( ( (prop->TypeL() & CFileManagerItemProperties::EForwardLocked)
- == CFileManagerItemProperties::EForwardLocked ) == !aMode )
- {
- ret = !aMode;
- }
-#endif // __KEEP_DRM_CONTENT_ON_PHONE
- CleanupStack::PopAndDestroy( prop );
- ++i;
- }
- CleanupStack::PopAndDestroy( indexArray );
- return ret;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::ShowContextSensitiveMenuL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::ShowContextSensitiveMenuL()
- {
- CEikMenuBar* menu = MenuBar();
- // set context sensitive menu
- menu->SetMenuTitleResourceId( R_FILEMANAGER_CONTEXT_SENSITIVE_MENUBAR );
- // show context sensitive menu
- TRAPD( err, menu->TryDisplayMenuBarL() );
- menu->SetMenuTitleResourceId( R_FILEMANAGER_MEMORY_STORE_MENUBAR );
- User::LeaveIfError( err );
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::ClearProgressBarL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::ClearProgressBarL()
- {
- FUNC_LOG
-
- iProgressInfo = NULL;
-
- if ( iProgressDialog )
- {
- iProgressDialog->ProcessFinishedL();
- iProgressDialog = NULL;
- }
- if ( iProgressDialogRefresh )
- {
- iProgressDialogRefresh->ProcessFinishedL();
- iProgressDialogRefresh = NULL;
- }
- delete iPeriodic;
- iPeriodic = NULL;
-
- delete iRefreshProgressDelayedStart;
- iRefreshProgressDelayedStart = NULL;
-
- iTotalTransferredBytes = 0;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::StoreIndex
-//
-// ------------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::StoreIndex()
- {
- if ( iContainer )
- {
- TInt index( iContainer->ListBoxCurrentItemIndex() );
- if ( index >= 0 &&
- index < iContainer->ListBoxNumberOfItems() )
- {
- iIndex = index; // Store view's internal index
-
- // Store navigation index
- TUid viewId( Id() );
- if ( viewId == CFileManagerAppUi::KFileManagerMemoryStoreViewId ||
- viewId == CFileManagerAppUi::KFileManagerFoldersViewId )
- {
- iEngine.SetCurrentIndex( index );
- }
- }
- }
- else
- {
- return EFalse;
- }
- return ETrue;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::DriveReadOnlyMmcL
-//
-// ------------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::DriveReadOnlyMmcL( const TInt aDrive ) const
- {
- TBool ret( EFalse );
- TUint32 drvState( 0 );
- TInt err( iEngine.DriveState( drvState, aDrive ) );
- if ( err == KErrNone &&
- ( drvState & TFileManagerDriveInfo::EDriveWriteProtected ) )
- {
- ret = ETrue;
- }
- if ( ret )
- {
-#ifdef RD_MULTIPLE_DRIVE
- HBufC* text = iEngine.GetFormattedDriveNameLC(
- aDrive,
- R_QTN_MEMC_MULTIPLE_MEMC_READ_ONLY );
- FileManagerDlgUtils::ShowErrorNoteL( *text );
- CleanupStack::PopAndDestroy( text );
-#else // RD_MULTIPLE_DRIVE
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_MEMC_MEMORYCARD_READ_ONLY );
-#endif // RD_MULTIPLE_DRIVE
- }
-
- return ret;
- }
-
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::DriveReadOnlyMmcL
-//
-// ------------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::DriveReadOnlyMmcL( const TDesC& aFullPath ) const
- {
- TBool ret( EFalse );
- if ( aFullPath.Length() )
- {
- TInt drive = TDriveUnit( aFullPath );
- ret = DriveReadOnlyMmcL( drive );
- }
- return ret;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::CurrentProcess
-//
-// ------------------------------------------------------------------------------
-//
-MFileManagerProcessObserver::TFileManagerProcess CFileManagerViewBase::CurrentProcess()
- {
- return iActiveProcess;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::Error
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::Error( TInt aError )
- {
- if ( aError != KErrNone )
- {
- ERROR_LOG1( "CFileManagerViewBase::Error()-aError=%d", aError )
- iEikonEnv->HandleError( aError );
- }
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::AddSendOptionL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::AddSendOptionL(
- CEikMenuPane& aMenuPane,
- const TInt aCommandIdAfter )
- {
- CSendUi& sendUi( static_cast< CFileManagerAppUi* >( AppUi() )->SendUiL() );
- TInt pos( 0 );
- aMenuPane.ItemAndPos( aCommandIdAfter, pos );
- CArrayFixFlat< TInt >* indexArray = MarkedArrayLC();
- TInt msgSize( KMessageSize );
- if ( indexArray->Count() == 1 &&
- !iEngine.IsFolder( indexArray->At( 0 ) ) )
- {
- msgSize = Int64ToInt( iEngine.GetFileSizesL( *indexArray ) );
- }
- CleanupStack::PopAndDestroy( indexArray );
- TSendingCapabilities caps(
- 0, msgSize, TSendingCapabilities::ESupportsAttachments );
- sendUi.AddSendMenuItemL( aMenuPane, pos, EFileManagerSend, caps );
- aMenuPane.SetItemSpecific(EFileManagerSend, ETrue);
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::DeleteStatusNotOk
-//
-// ------------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::DeleteStatusNotOkL(
- CFileManagerItemProperties& aProp, TInt aSelectionCount ) const
- {
- if ( DriveReadOnlyMmcL( aProp.FullPath() ) )
- {
- // Can't delete from read-only MMC card
- return ETrue;
- }
-
- TUint32 itemType( aProp.TypeL() );
- if ( !aSelectionCount &&
- ( itemType & KDefaultFolderMask ) == KDefaultFolderMask )
- {
- // Can't delete default folder
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_FMGR_ERROR_DEL_DEF_FLDR );
- return ETrue;
- }
- if ( aSelectionCount <= 1 &&
- ( itemType & CFileManagerItemProperties::EOpen ) )
- {
- // Can't delete open file
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_FMGR_ERROR_DELETE_FILE_OPEN );
- return ETrue;
- }
-
- return EFalse;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::DeleteItemsL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::DeleteItemsL( TInt aIndex )
- {
-
- CArrayFixFlat<TInt>* deleteArray = MarkedArrayLC();
- TInt newIndex( MinIndex( *deleteArray ) );
- delete iActiveDelete;
- iActiveDelete = NULL;
- iActiveDelete = iEngine.CreateActiveDeleteL( *deleteArray );
- delete iWaitNoteWrapper;
- iWaitNoteWrapper = NULL;
- iWaitNoteWrapper = CAknWaitNoteWrapper::NewL();
- iActiveProcess = EDeleteProcess;
- TRAPD( err, iWaitNoteWrapper->ExecuteL(
- R_FILEMANAGER_DELETE_WAIT_DIALOG, *iActiveDelete ) );
- iActiveProcess = ENoProcess;
- User::LeaveIfError( err );
-
- HBufC* fileNameBuf = HBufC::NewLC( KMaxFileName );
- TPtr fileName( fileNameBuf->Des() );
-
- err = iActiveDelete->GetError( fileName );
-
- switch ( err )
- {
- case KErrInUse:
- case KErrFmgrSeveralFilesInUse:
- {
- ERROR_LOG1( "CFileManagerViewBase::DeleteItemsL()-err=%d", err )
- if ( iEngine.IsFolder( aIndex ) )
- {
- if ( err == KErrFmgrSeveralFilesInUse )
- {
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_FMGR_ERROR_DEL_FLDR_OPEN_SE );
- }
- else
- {
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_FMGR_ERROR_DEL_FLDR_OPEN_1 );
- }
- }
- else
- {
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_FMGR_ERROR_DELETE_FILE_OPEN );
- }
- break;
- }
- case KErrNone:
- {
- if ( iContainer )
- {
- //CEikListBox& listBox( iContainer->ListBox() );
- //AknSelectionService::HandleItemRemovalAndPositionHighlightL(
- // &listBox, listBox.CurrentItemIndex(), *deleteArray);
-
-#ifndef RD_DRM_RIGHTS_MANAGER_REMOVAL
- if ( FeatureManager().IsDrmFullSupported() )
- {
- TInt deletedItems( 0 );
- TInt deletedDrmItems( iActiveDelete->DeletedDrmItems( deletedItems ) );
- if( deletedDrmItems )
- {
- if( deletedDrmItems > 1 )
- {
- FileManagerDlgUtils::ShowInfoQueryL(
- R_QTN_DRM_MOS_DELETED, deletedDrmItems );
- }
- else
- {
- FileManagerDlgUtils::ShowInfoQueryL(
- R_QTN_DRM_MO_DELETED, fileName );
- }
- }
- }
-#endif // RD_DRM_RIGHTS_MANAGER_REMOVAL
-
- // Set focus to the item after selection
- iContainer->SetIndex( newIndex );
- }
- break;
- }
- default:
- {
- ERROR_LOG1( "CFileManagerViewBase::DeleteItemsL()-err=%d", err )
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_FLDR_CANT_DELETE_ITEM, fileName );
- break;
- }
- }
- CleanupStack::PopAndDestroy( fileNameBuf );
- CleanupStack::PopAndDestroy( deleteArray );
- StoreIndex();
- iEngine.SetObserver( this );
- iEngine.RefreshDirectory();
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::HasInfoUrlL
-//
-// ------------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::HasInfoUrlL( TInt aIndex )
- {
- if ( iEngine.IsFolder( aIndex ) )
- {
- return EFalse;
- }
- TBool hasUrl( EFalse );
- HBufC8* url = NULL;
- HBufC* fullPath = iEngine.IndexToFullPathLC( aIndex );
- CDRMHelper* drmHelper = CDRMHelper::NewLC( *iEikonEnv );
-
- TRAPD( err, hasUrl = drmHelper->HasInfoUrlL( *fullPath, url ) );
- if ( hasUrl && url && err == KErrNone )
- {
- hasUrl = url->Length() > 0;
- }
- else
- {
- hasUrl = EFalse;
- }
-
- ERROR_LOG2( "CFileManagerViewBase::HasInfoUrlL()-hasUrl=%d,err=%d", hasUrl, err )
-
- delete url;
- CleanupStack::PopAndDestroy( drmHelper );
- CleanupStack::PopAndDestroy( fullPath );
- return hasUrl;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::OpenInfoUrlL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::OpenInfoUrlL( TInt aIndex )
- {
- if ( iEngine.IsFolder( aIndex ) )
- {
- return;
- }
- HBufC* fullPath = iEngine.IndexToFullPathLC( aIndex );
- CDRMHelper* drmHelper = CDRMHelper::NewLC( *iEikonEnv );
-
- // Call returns after browser has been closed
-#ifdef FILE_MANAGER_ERROR_LOG_ENABLED
- TRAPD( err, drmHelper->OpenInfoUrlL( *fullPath ) );
- ERROR_LOG1( "CFileManagerViewBase::OpenInfoUrlL()-err=%d", err )
-#else // FILE_MANAGER_ERROR_LOG_ENABLED
- TRAP_IGNORE( drmHelper->OpenInfoUrlL( *fullPath ) );
-#endif // FILE_MANAGER_ERROR_LOG_ENABLED
-
- CleanupStack::PopAndDestroy( drmHelper );
- CleanupStack::PopAndDestroy( fullPath );
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::CheckFileRightsAndInformIfExpiredL
-//
-// ------------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::CheckFileRightsAndInformIfExpiredL(
- const TDesC& aFullPath )
- {
- if ( !FeatureManager().IsDrmFullSupported() )
- {
- return ETrue;
- }
- TBool expired( EFalse );
- TBool wmDrm( IsWmDrmFile( aFullPath ) );
- if ( !wmDrm ) // Ignore WM DRM files
- {
- TBool dummy( EFalse );
- CDRMHelperRightsConstraints* dummy2 = NULL;
- CDRMHelperRightsConstraints* dummy3 = NULL;
- CDRMHelperRightsConstraints* dummy4 = NULL;
- CDRMHelperRightsConstraints* dummy5 = NULL;
- CDRMHelper* drmHelper = CDRMHelper::NewLC( *iEikonEnv );
- TRAPD( err, drmHelper->GetRightsDetailsL(
- aFullPath, 0, expired, dummy, dummy2, dummy3, dummy4, dummy5 ) );
- delete dummy2;
- delete dummy3;
- delete dummy4;
- delete dummy5;
- if ( expired )
- {
- err = KErrCANoPermission;
- }
- if ( err == KErrCANoRights || err == KErrCANoPermission )
- {
- // Rights expired or missing, show note or try get silent rights
- expired = ETrue;
- ERROR_LOG1( "CFileManagerViewBase::CheckFileRightsAndInformIfExpiredL-err=%d",
- err )
- HBufC8* previewUri = NULL;
- if ( drmHelper->HandleErrorOrPreviewL( err, aFullPath, previewUri ) == KErrNone )
- {
- expired = EFalse;
- }
- delete previewUri; // Not needed
- }
- CleanupStack::PopAndDestroy( drmHelper );
- }
- ERROR_LOG2(
- "CFileManagerViewBase::CheckFileRightsAndInformIfExpiredL-expired=%d,wmDrm=%d",
- expired, wmDrm )
- return !expired;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::HandleFileNotFoundL
-//
-// ------------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::HandleFileNotFoundL( TInt aError )
- {
- if ( aError == KErrNotFound )
- {
- iEngine.SetObserver( this );
- iEngine.RefreshDirectory();
- return ETrue;
- }
- if ( aError == KErrPathNotFound )
- {
- TInt count( iEngine.FolderLevel() );
- TBool connectedRemoteDrive( EFalse );
- RefreshDriveInfoL();
-
- TFileManagerDriveInfo& drvInfo( DriveInfo() );
- TBool remoteDrive( EFalse );
- // Check if drive is remote drive and is it connected or not
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveRemote )
- {
- remoteDrive = ETrue;
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveConnected )
- {
- connectedRemoteDrive = ETrue;
- }
- }
- // Check if drive has been disconnected and reconnect canceled
- if ( remoteDrive && !connectedRemoteDrive )
- {
- // Do only root refresh if user is already got back in main view
- if ( Id() == CFileManagerAppUi::KFileManagerMainViewId &&
- iEngine.NavigationLevel() < 0 )
- {
- iEngine.SetObserver( this );
- iEngine.RefreshDirectory();
- }
- // Open memory store view to show not connected.
- else if ( Id() != CFileManagerAppUi::KFileManagerMemoryStoreViewId )
- {
- iIndex = 0;
- static_cast< CFileManagerAppUi* >( AppUi() )->ActivateMemoryStoreViewL();
- }
- else
- {
- iIndex = 0;
- if ( iContainer )
- {
- iContainer->SetListEmptyL();
- }
- DirectoryChangedL();
- }
- }
- // Check if fetch was canceled in connected memory store view
- else if ( connectedRemoteDrive &&
- Id() == CFileManagerAppUi::KFileManagerMemoryStoreViewId )
- {
- static_cast< CFileManagerAppUi* >( AppUi() )->ActivateMainViewL();
- }
- else if ( count > 0 &&
- ( connectedRemoteDrive ||
- !BaflUtils::PathExists(
- iEikonEnv->FsSession(), iEngine.CurrentDirectory() ) ) )
- {
- // Go back to last valid folder
- CFileManagerAppUi* appUi =
- static_cast< CFileManagerAppUi* >( AppUi() );
- TInt err( KErrNone );
- for ( TInt i( 0 ); i < count; i++ )
- {
- TRAP( err, iEngine.BackstepL() );
- if ( err == KErrNone )
- {
- break;
- }
- }
- if ( iEngine.FolderLevel() ||
- iEngine.State() == CFileManagerEngine::ESearch )
- {
- iEngine.SetObserver( this );
- iEngine.RefreshDirectory();
- }
- else
- {
- appUi->CloseFoldersViewL();
- }
- }
- else
- {
- // Refresh root folder
- iEngine.SetObserver( this );
- iEngine.RefreshDirectory();
- }
- return ETrue;
- }
- return EFalse;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::ScreenDeviceChanged
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::ScreenDeviceChanged()
- {
- if ( iContainer )
- {
- iContainer->SetRect( ClientRect() );
- iContainer->DrawDeferred();
- }
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::NotifyL
-//
-// ------------------------------------------------------------------------------
-//
-TInt CFileManagerViewBase::NotifyL( TFileManagerNotify aType,
- TInt aData, const TDesC& aName )
- {
- TInt ret( KErrNone );
- switch ( aType )
- {
- case ENotifyDisksChanged:
- {
- if ( iDirectoryRefreshDenied )
- {
- iDirectoryRefreshPostponed = ETrue;
- }
- else if ( iActiveProcess == ENoProcess && !IsRefreshInProgress() )
- {
- StoreIndex();
- iEngine.SetObserver( this );
- iEngine.RefreshDirectory();
- }
-#ifndef RD_MULTIPLE_DRIVE
- else if ( iActiveProcess == EEjectProcess )
- {
- // Memory card was put back, complete query
- if ( iEngine.AnyEjectableDrivePresent() )
- {
- delete iEjectQueryDialog;
- iEjectQueryDialog = NULL;
- }
- }
-#endif // RD_MULTIPLE_DRIVE
- break;
- }
- case ENotifyBackupMemoryLow:
- {
- if( aData < KEstimateLowerLimit )
- {
- ret = KErrDiskFull;
- }
- else if( aData < KEstimateUpperLimit )
- {
-
-#ifdef RD_FILE_MANAGER_BACKUP
- CFileManagerBackupSettings& settings( iEngine.BackupSettingsL() );
-#endif // RD_FILE_MANAGER_BACKUP
-
- if ( !FileManagerDlgUtils::ShowConfirmQueryWithYesNoL(
-#ifdef RD_FILE_MANAGER_BACKUP
- R_QTN_FMGR_BACKUP_TIGHT_MEMORY,
- iEngine.DriveName( settings.TargetDrive() )
-#else // RD_FILE_MANAGER_BACKUP
- R_QTN_CONFIRM_BACKUP_LEVEL1
-#endif // RD_FILE_MANAGER_BACKUP
- ) )
- {
- ret = KErrCancel;
- }
- }
- break;
- }
- case ENotifyForcedFormat:
- {
- StopProgressDialogAndStoreValues();
-
- TInt textId( R_QTN_CONFIRM_FORMAT_TEXT2 );
-#ifdef RD_MULTIPLE_DRIVE
- if ( DriveInfo().iState & TFileManagerDriveInfo::EDriveMassStorage )
- {
- textId = R_QTN_FMGR_FORMAT_MASS_QUERY2;
- }
-#endif // RD_MULTIPLE_DRIVE
-
- TBool query( FileManagerDlgUtils::ShowConfirmQueryWithYesNoL( textId ) );
- LaunchProgressDialogL(
- iProgressFinalValue, iProgressCurrentValue, iActiveProcess );
- return query;
- }
- case ENotifyFileOpenDenied:
- {
- TBool launchProgress( StopProgressDialogAndStoreValues() );
-
- ret = !CheckFileRightsAndInformIfExpiredL( aName );
- if ( launchProgress )
- {
- LaunchProgressDialogL(
- iProgressFinalValue, iProgressCurrentValue, iActiveProcess );
- }
- break;
- }
- default:
- {
- break;
- }
- }
- return ret;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::MemoryStoreMenuFilteringL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::MemoryStoreMenuFilteringL(
- CEikMenuPane& aMenuPane )
- {
- TBool isSearchOn( iEngine.State() == CFileManagerEngine::ESearch );
- TRAP_IGNORE ( RefreshDriveInfoL() );
- TFileManagerDriveInfo& drvInfo( DriveInfo() );
- TInt driveNumber = drvInfo.iDrive;
- iEngine.GetDriveInfoL(driveNumber,drvInfo);
-
- // Common remote drive filtering
- RemoteDriveCommonFilteringL( aMenuPane );
- if( iContainer->IsSearchFieldVisible() &&
- !FilesCountInSearchField() )
- {
- aMenuPane.SetItemDimmed( EFileManagerMark, ETrue );
- }
- if ( iContainer->ListBoxNumberOfItems() )
- {
- if ( !iContainer->ListBoxSelectionIndexesCount() )
- {
- TUint32 fileType( iEngine.FileTypeL(
- iContainer->ListBoxCurrentItemIndex() ) );
- if ( ( fileType & KDefaultFolderMask ) == KDefaultFolderMask )
- {
- aMenuPane.SetItemDimmed( EFileManagerMoveToFolder, ETrue );
- }
- }
- }
- else
- {
- aMenuPane.SetItemDimmed( EFileManagerMoveToFolder, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerCopyToFolder, ETrue );
- }
- TInt index(iContainer->ListBoxCurrentItemIndex());
- TUint32 fileType(iEngine.FileTypeL(index));
- if (!(fileType & CFileManagerItemProperties::EFolder))
- {
- aMenuPane.SetItemDimmed(EFileManagerMoveToFolder, ETrue);
- }
- CFileManagerFeatureManager& featureManager( FeatureManager() );
-
-#ifdef RD_MULTIPLE_DRIVE
- // No format item for mass storage in embedded mode dimming
- if ( !( drvInfo.iState & TFileManagerDriveInfo::EDriveFormattable ) )
- {
- aMenuPane.SetItemDimmed( EFileManagerFormatMassStorage, ETrue );
- }
-#endif // RD_MULTIPLE_DRIVE
-
- // Memory store specific remote drive filtering
- if ( !featureManager.IsRemoteStorageFwSupported() ||
- !( drvInfo.iState & TFileManagerDriveInfo::EDriveRemote ) ||
- !( drvInfo.iState & TFileManagerDriveInfo::EDriveConnected ) )
- {
- // For disconnected or non remote drive
- aMenuPane.SetItemDimmed( EFileManagerRefreshRemoteDrive, ETrue );
- }
-
- if ( !featureManager.IsHelpSupported() )
- {
- // No help item dimming
- aMenuPane.SetItemDimmed( EAknCmdHelp, ETrue );
- }
- if ( !featureManager.IsIrdaSupported() )
- {
- // No infra red item dimming
- aMenuPane.SetItemDimmed( EFileManagerReceiveViaIR, ETrue );
- }
- if ( isSearchOn )
- {
- // Search view item dimming
- aMenuPane.SetItemDimmed( EFileManagerRename, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerReceiveViaIR, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerOrganise, ETrue );
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCard, ETrue );
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCardPassword, ETrue );
- //aMenuPane.SetItemDimmed( EFileManagerUnlockMemoryCard, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerRefreshRemoteDrive, ETrue );
-#ifdef RD_MULTIPLE_DRIVE
- aMenuPane.SetItemDimmed( EFileManagerFormatMassStorage, ETrue );
-#endif // RD_MULTIPLE_DRIVE
- aMenuPane.SetItemDimmed( EFileManagerSort, ETrue );
- }
- else
- {
- aMenuPane.SetItemDimmed( EFileManagerSearchSort, ETrue );
- }
- //dim the item unconditionally
- aMenuPane.SetItemDimmed( EFileManagerFormatMassStorage, ETrue );
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveWriteProtected )
- {
- // Write protected item dimming
- aMenuPane.SetItemDimmed( EFileManagerRename, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerDelete, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerReceiveViaIR, ETrue );
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCard, ETrue );
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCardPassword, ETrue );
-#ifdef RD_MULTIPLE_DRIVE
- aMenuPane.SetItemDimmed( EFileManagerFormatMassStorage, ETrue );
-#endif // RD_MULTIPLE_DRIVE
- }
-
-#ifdef RD_MULTIPLE_DRIVE
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveMassStorage )
- {
- // Mass storage item dimming
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCard, ETrue );
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCardPassword, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerUnlockMemoryCard, ETrue );
-
- if ( !( drvInfo.iState & TFileManagerDriveInfo::EDrivePresent ) )
- {
- aMenuPane.SetItemDimmed( EFileManagerFormatMassStorage, ETrue );
- }
- }
- else
-#endif // RD_MULTIPLE_DRIVE
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveRemovable )
- {
- // Memory card item dimming
- if ( !( drvInfo.iState & TFileManagerDriveInfo::EDrivePresent ) ||
- ( drvInfo.iState & ( TFileManagerDriveInfo::EDriveCorrupted |
- TFileManagerDriveInfo::EDriveLocked ) ) )
- {
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCardPassword, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerDetails, ETrue );
- }
- if ( ( drvInfo.iState & TFileManagerDriveInfo::EDriveCorrupted ) ||
- !( drvInfo.iState & TFileManagerDriveInfo::EDriveLocked ) )
- {
- aMenuPane.SetItemDimmed( EFileManagerUnlockMemoryCard, ETrue );
- }
-// if ( !( drvInfo.iState & TFileManagerDriveInfo::EDriveLockable ) )
-// {
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCardPassword, ETrue );
-// }
- if ( !featureManager.IsMmcPassWdSupported() )
- {
- //aMenuPane.SetItemDimmed( EFileManagerMemoryCardPassword, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerUnlockMemoryCard, ETrue );
- }
-#ifdef RD_MULTIPLE_DRIVE
- aMenuPane.SetItemDimmed( EFileManagerFormatMassStorage, ETrue );
-#endif // RD_MULTIPLE_DRIVE
- }
- else
- {
- // No mass storage or memory card item dimming
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCard, ETrue );
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCardPassword, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerUnlockMemoryCard, ETrue );
-#ifdef RD_MULTIPLE_DRIVE
- aMenuPane.SetItemDimmed( EFileManagerFormatMassStorage, ETrue );
-#endif // RD_MULTIPLE_DRIVE
- }
-
-// CEikListBox& listBox = iContainer->ListBox();
- TBool dimSend( EFalse );
-
- if ( iContainer->ListBoxSelectionIndexesCount() )
- {
- // Selections in list
- aMenuPane.SetItemDimmed( EFileManagerOpen, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerRename, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerDetails, ETrue );
-
- if ( !featureManager.IsDrmFullSupported() &&
- AreChosenFilesProtectedL( ETrue ) )
- {
- dimSend = ETrue;
- }
-
-
- // Hide empty details if no item or memory specific details
- // can be shown.
- if ( isSearchOn ||
- ( drvInfo.iState & TFileManagerDriveInfo::EDriveRemote ) )
- {
- aMenuPane.SetItemDimmed( EFileManagerDetails, ETrue );
- }
-
- if ( !( drvInfo.iState & TFileManagerDriveInfo::EDrivePresent ) ||
- ( ( drvInfo.iState & TFileManagerDriveInfo::EDriveRemote ) &&
- !( drvInfo.iState & TFileManagerDriveInfo::EDriveConnected ) ) )
- {
- // Handle unavailable drive OR disconnected remote drive
- dimSend = ETrue;
- aMenuPane.SetItemDimmed( EFileManagerSort, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerOrganise, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerMark, ETrue );
- }
- }
- else if ( iContainer->ListBoxNumberOfItems() )
- {
- // Check if there is files on the list
- TInt files( iEngine.FilesInFolderL() );
- if ( !files )
- {
- dimSend = ETrue;
- aMenuPane.SetItemDimmed( EFileManagerMark, ETrue );
- }
-
- // There is items in list, check selection type
- TUint32 fileType( iEngine.FileTypeL(
- iContainer->ListBoxCurrentItemIndex() ) );
- if ( ( fileType & KDefaultFolderMask ) == KDefaultFolderMask )
- {
- dimSend = ETrue;
- aMenuPane.SetItemDimmed( EFileManagerDelete, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerRename, ETrue );
- }
- else if ( fileType & CFileManagerItemProperties::EFolder )
- {
- dimSend = ETrue;
- }
-
- if ( fileType & CFileManagerItemProperties::EPlaylist )
- {
- dimSend = ETrue;
- }
-
- // When full OMA DRM is in use, it is ok to show send option
- if( ( fileType & CFileManagerItemProperties::EForwardLocked ) &&
- !featureManager.IsDrmFullSupported() )
- {
- dimSend = ETrue;
- }
- if ( ( drvInfo.iState & TFileManagerDriveInfo::EDriveRemote ) &&
- !( drvInfo.iState & TFileManagerDriveInfo::EDriveConnected ) )
- {
- // Handle disconnected remote drive
- dimSend = ETrue;
- }
- }
- else
- {
- // List is empty
- aMenuPane.SetItemDimmed( EFileManagerOpen, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerDelete, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerMark, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerRename, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerSort, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerSearchSort, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerDetails, ETrue );
- dimSend = ETrue;
-
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveWriteProtected )
- {
- // Handle write protected drive
- aMenuPane.SetItemDimmed( EFileManagerOrganise, ETrue );
- }
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveRemote )
- {
- // Handle empty remote folder
- aMenuPane.SetItemDimmed( EFileManagerDetails, ETrue );
- }
-
- if ( ( drvInfo.iState & TFileManagerDriveInfo::EDriveRemote ) &&
- !( drvInfo.iState & TFileManagerDriveInfo::EDriveConnected ) )
- {
- // Handle disconnected remote drive
- aMenuPane.SetItemDimmed( EFileManagerReceiveViaIR, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerOrganise, ETrue );
-// aMenuPane.SetItemDimmed( EFileManagerDetails, ETrue );
- }
- else if ( !( drvInfo.iState & TFileManagerDriveInfo::EDrivePresent ) ||
- ( drvInfo.iState & (
- TFileManagerDriveInfo::EDriveCorrupted |
- TFileManagerDriveInfo::EDriveLocked ) ) )
- {
- // Handle unavailable drive
-// aMenuPane.SetItemDimmed( EFileManagerDetails, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerReceiveViaIR, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerOrganise, ETrue );
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCardPassword, ETrue );
-
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveRemovable &&
- !( drvInfo.iState & TFileManagerDriveInfo::EDriveLocked ) )
- {
- aMenuPane.SetItemDimmed( EFileManagerUnlockMemoryCard, ETrue );
- }
- }
- else if ( isSearchOn ||
- !BaflUtils::PathExists(
- iEikonEnv->FsSession(), iEngine.CurrentDirectory() ) )
- {
- // Handle empty search results and invalid path
- if ( isSearchOn || !iEngine.CurrentDirectory().Length() )
- {
- aMenuPane.SetItemDimmed( EFileManagerReceiveViaIR, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerOrganise, ETrue );
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCardPassword, ETrue );
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCard, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerUnlockMemoryCard, ETrue );
-// aMenuPane.SetItemDimmed( EFileManagerDetails, ETrue );
- }
- else
- {
- // BaflUtils::PathExists does not work for remote drive root dirs.
- if( drvInfo.iState & TFileManagerDriveInfo::EDriveRemote )
- {
- _LIT( KRootFolder, "?:\\" );
- if ( iEngine.CurrentDirectory().MatchF( KRootFolder ) )
- {
- User::Leave( KErrPathNotFound );
- }
- }
- else
- {
- User::Leave( KErrPathNotFound );
- }
- }
- }
- }
-
- if ( !dimSend )
- {
- AddSendOptionL( aMenuPane, EFileManagerDelete );
- }
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::OrganiseMenuFilteringL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::OrganiseMenuFilteringL( CEikMenuPane& aMenuPane )
- {
-// CEikListBox& listBox( iContainer->ListBox() );
-
-
- // Search view item dimming
- if( iEngine.State() == CFileManagerEngine::ESearch )
- {
- aMenuPane.SetItemDimmed( EFileManagerNewFolder, ETrue );
- }
-
- TFileManagerDriveInfo& drvInfo( DriveInfo() );
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveWriteProtected )
- {
- // Write protected item dimming
- aMenuPane.SetItemDimmed( EFileManagerNewFolder, ETrue );
-
- }
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::DetailsMenuFilteringL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::DetailsMenuFilteringL( CEikMenuPane& aMenuPane )
- {
- TInt index( iContainer->ListBoxCurrentItemIndex() );
- TUint32 fileType( iEngine.FileTypeL( index ) );
- if ( fileType & CFileManagerItemProperties::EFolder )
- {
- aMenuPane.SetItemDimmed( EFileManagerFileDetails, ETrue );
- }
- else
- {
- aMenuPane.SetItemDimmed( EFileManagerFolderDetails, ETrue );
- }
- if ( !FeatureManager().IsDrmFullSupported() ||
- !( fileType & CFileManagerItemProperties::EDrmProtected ) ||
- !HasInfoUrlL( index ) )
- {
- aMenuPane.SetItemDimmed( EFileManagerMoreInfoOnline, ETrue );
- }
- }
-
-//// ------------------------------------------------------------------------------
-//// CFileManagerViewBase::MemoryCardMenuFilteringL
-////
-//// ------------------------------------------------------------------------------
-////
-//void CFileManagerViewBase::MemoryCardMenuFilteringL( CEikMenuPane& aMenuPane )
-// {
-// TFileManagerDriveInfo& drvInfo( DriveInfo() );
-//
-// if ( drvInfo.iState & ( TFileManagerDriveInfo::EDriveCorrupted |
-// TFileManagerDriveInfo::EDriveLocked |
-// TFileManagerDriveInfo::EDriveMassStorage ) )
-// {
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCardName, ETrue );
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCardRename, ETrue );
-// }
-// else
-// {
-// if ( drvInfo.iName.Length() )
-// {
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCardName, ETrue );
-// }
-// else
-// {
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCardRename, ETrue );
-// }
-// }
-//
-// if ( !( drvInfo.iState & TFileManagerDriveInfo::EDriveFormattable ) )
-// {
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCardFormat, ETrue );
-// }
-// }
-//
-//// ------------------------------------------------------------------------------
-//// CFileManagerViewBase::MemoryCardPasswordMenuFilteringL
-////
-//// ------------------------------------------------------------------------------
-////
-//void CFileManagerViewBase::MemoryCardPasswordMenuFilteringL( CEikMenuPane& aMenuPane )
-// {
-// TFileManagerDriveInfo& drvInfo( DriveInfo() );
-//
-// if ( drvInfo.iState & TFileManagerDriveInfo::EDrivePasswordProtected )
-// {
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCardPasswordSet, ETrue );
-// }
-// else
-// {
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCardPasswordChange, ETrue );
-// aMenuPane.SetItemDimmed( EFileManagerMemoryCardPasswordRemove, ETrue );
-// }
-// }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::ContextSensitiveMenuFilteringL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::ContextSensitiveMenuFilteringL( CEikMenuPane& aMenuPane )
- {
- TFileManagerDriveInfo& drvInfo( DriveInfo() );
- TInt driveNumber = drvInfo.iDrive;
- iEngine.GetDriveInfoL(driveNumber,drvInfo);
-
- // Check if there are files to send
- TInt dummy( 0 );
- CArrayFixFlat< TInt >* files = GetSendFilesLC( dummy );
-
- TBool dimSend( EFalse );
- if ( ( drvInfo.iState & TFileManagerDriveInfo::EDriveRemote ) &&
- !( drvInfo.iState & TFileManagerDriveInfo::EDriveConnected ) )
- {
- dimSend = ETrue;
- }
-
- if ( files->Count() && !dimSend )
- {
- AddSendOptionL( aMenuPane, EFileManagerOrganise );
- }
- CleanupStack::PopAndDestroy( files );
-
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveWriteProtected )
- {
- // Write protected item dimming
- aMenuPane.SetItemDimmed( EFileManagerMemoryStorageFormat, ETrue );
- }
-
- if ( iEngine.State() == CFileManagerEngine::ESearch ||
- !( drvInfo.iState & TFileManagerDriveInfo::EDriveRemovable ) )
- {
- // No memory card item dimming
- aMenuPane.SetItemDimmed( EFileManagerUnlockMemoryCard, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerMemoryStorageFormat, ETrue );
- }
- else
- {
- // Memory card item dimming
- if ( !( drvInfo.iState & TFileManagerDriveInfo::EDriveLocked ) )
- {
- aMenuPane.SetItemDimmed( EFileManagerUnlockMemoryCard, ETrue );
- }
- if ( !( drvInfo.iState & TFileManagerDriveInfo::EDriveCorrupted ) ||
- !( drvInfo.iState & TFileManagerDriveInfo::EDriveFormattable ) )
- {
- aMenuPane.SetItemDimmed( EFileManagerMemoryStorageFormat, ETrue );
- }
- }
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::DriveInfo
-//
-// -----------------------------------------------------------------------------
-//
-TFileManagerDriveInfo& CFileManagerViewBase::DriveInfo() const
- {
- return static_cast< CFileManagerAppUi* >( AppUi() )->DriveInfo();
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::RefreshDriveInfoL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::RefreshDriveInfoL()
- {
- if ( !iEngine.CurrentDirectory().Length() )
- {
- return;
- }
- iEngine.GetDriveInfoL( DriveInfo() );
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::StartProcessL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::StartProcessL(
- MFileManagerProcessObserver::TFileManagerProcess aProcess,
- TInt aValue )
- {
- if ( iActiveProcess != ENoProcess )
- {
- return;
- }
- LaunchProgressDialogL( KMaxTInt, 0, aProcess );
- iEngine.SetObserver( this );
- iActiveProcess = aProcess;
- TInt err( KErrNone );
- switch ( aProcess )
- {
- case EFormatProcess:
- {
- TRAP( err, iEngine.StartFormatProcessL( aValue ) );
- break;
- }
- case EBackupProcess:
- case ERestoreProcess: // FALLTHROUGH
- {
- CFileManagerAppUi* appUi = static_cast< CFileManagerAppUi* >( AppUi() );
- appUi->BackupOrRestoreStarted();
-
- TRAP( err, iEngine.StartBackupProcessL( aProcess ) );
- break;
- }
- case EEjectProcess:
- {
- TRAP( err, iEngine.StartEjectProcessL( aValue ) );
- break;
- }
- default:
- {
- TRAP( err, ClearProgressBarL() );
- iActiveProcess = ENoProcess;
- break;
- }
- }
- if ( err != KErrNone )
- {
- // Clean up the active process before forwarding leave
- ERROR_LOG2(
- "CFileManagerViewBase::StartProcessL-aProcess=%d,err=%d",
- aProcess, err )
- iActiveProcess = ENoProcess;
- User::Leave( err );
- }
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::CmdUnlockDriveL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::CmdUnlockDriveL()
- {
- TFileManagerDriveInfo drvInfo;
- if ( DriveInfoAtCurrentPosL( drvInfo ) < 0 )
- {
- return; // No drive selected
- }
-
- if ( !UnlockRemovePasswordL( drvInfo.iDrive, EFalse ) ) // Unlock only
- {
- RefreshDriveInfoL();
- iEngine.SetObserver( this );
- iEngine.RefreshDirectory();
- }
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::CmdFormatDriveL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::CmdFormatDriveL()
- {
- StoreIndex();
- TFileManagerDriveInfo drvInfo;
- if ( DriveInfoAtCurrentPosL( drvInfo ) < 0 )
- {
- return; // No drive selected
- }
-
- if ( !( drvInfo.iState & ( TFileManagerDriveInfo::EDriveRemovable |
- TFileManagerDriveInfo::EDriveFormattable ) ) ||
- ( drvInfo.iState & TFileManagerDriveInfo::EDriveWriteProtected ) )
- {
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_MEMORYCARD_READONLY );
- return;
- }
-
- TBool query( EFalse );
-#ifdef RD_MULTIPLE_DRIVE
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveUsbMemory )
- {
- HBufC* text = iEngine.GetFormattedDriveNameLC(
- drvInfo.iDrive, R_QTN_FMGR_USB_MEMORY_FORMAT_QUERY );
- query = FileManagerDlgUtils::ShowConfirmQueryWithYesNoL( *text );
- CleanupStack::PopAndDestroy( text );
- }
- else if ( drvInfo.iState & TFileManagerDriveInfo::EDriveMassStorage )
- {
- HBufC* text = iEngine.GetFormattedDriveNameLC(
- drvInfo.iDrive, R_QTN_FMGR_FORMAT_MASS_QUERY1 );
- query = FileManagerDlgUtils::ShowConfirmQueryWithYesNoL( *text );
- CleanupStack::PopAndDestroy( text );
- }
- else
- {
-#endif // RD_MULTIPLE_DRIVE
- query = FileManagerDlgUtils::ShowConfirmQueryWithYesNoL(
- R_QTN_CONFIRM_FORMAT_TEXT );
-#ifdef RD_MULTIPLE_DRIVE
- }
-#endif // RD_MULTIPLE_DRIVE
-
- if ( query )
- {
- StartProcessL( EFormatProcess, drvInfo.iDrive );
- }
- }
-
-//// ------------------------------------------------------------------------------
-//// CFileManagerViewBase::CmdRenameDriveL
-////
-//// ------------------------------------------------------------------------------
-////
-//void CFileManagerViewBase::CmdRenameDriveL()
-// {
-// TFileManagerDriveInfo& drvInfo( DriveInfo() );
-// if ( drvInfo.iState & TFileManagerDriveInfo::EDriveWriteProtected )
-// {
-// FileManagerDlgUtils::ShowErrorNoteL( R_QTN_MEMORYCARD_READONLY );
-// return;
-// }
-// StoreIndex();
-// RenameDriveL( EFalse );
-// iEngine.SetObserver( this );
-// iEngine.RefreshDirectory();
-// }
-//
-//// ------------------------------------------------------------------------------
-//// CFileManagerViewBase::CmdSetDrivePasswordL
-////
-//// ------------------------------------------------------------------------------
-////
-//void CFileManagerViewBase::CmdSetDrivePasswordL()
-// {
-// TBuf< KFmgrMaxMediaPassword > nullPwd;
-// TBuf< KFmgrMaxMediaPassword > pwd;
-// TInt ret( KErrNone );
-// if( FileManagerDlgUtils::ShowPasswordQueryL( pwd ) )
-// {
-// EmptyPwd( nullPwd );
-// ret = UpdatePasswordL( nullPwd, pwd );
-// if( ret == KErrNone )
-// {
-// FileManagerDlgUtils::ShowConfirmNoteL( R_QTN_PASSWORD_SET_TEXT );
-// RefreshDriveInfoL();
-// }
-// else
-// {
-// FileManagerDlgUtils::ShowErrorNoteL( R_QTN_CRITICAL_ERROR );
-// }
-// }
-// }
-//
-//// ------------------------------------------------------------------------------
-//// CFileManagerViewBase::CmdChangeDrivePasswordL
-////
-//// ------------------------------------------------------------------------------
-////
-//void CFileManagerViewBase::CmdChangeDrivePasswordL()
-// {
-// 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 ) )
-// {
-// err = UpdatePasswordL( oldPwd, oldPwd );
-// if( err == KErrNone )
-// {
-// isDone = ETrue;
-// }
-// else
-// {
-// FileManagerDlgUtils::ShowErrorNoteL(
-// R_QTN_PASSWORDS_WRONG_TEXT );
-// }
-// }
-// else
-// {
-// isDone = ETrue;
-// isCanceled = ETrue;
-// }
-// }
-//
-// // Then query for the new password
-// if( !isCanceled )
-// {
-// if( FileManagerDlgUtils::ShowPasswordQueryL( pwd ) )
-// {
-// err = UpdatePasswordL( oldPwd, pwd );
-// if( err == KErrNone )
-// {
-// FileManagerDlgUtils::ShowConfirmNoteL(
-// R_QTN_PASSWORD_CHANGED_TEXT );
-// }
-// else
-// {
-// FileManagerDlgUtils::ShowErrorNoteL(
-// R_QTN_CRITICAL_ERROR );
-// }
-// }
-// }
-// }
-//
-//// ------------------------------------------------------------------------------
-//// CFileManagerViewBase::CmdRemoveDrivePasswordL
-////
-//// ------------------------------------------------------------------------------
-////
-//void CFileManagerViewBase::CmdRemoveDrivePasswordL()
-// {
-// if( !UnlockRemovePasswordL( ETrue ) )
-// {
-// FileManagerDlgUtils::ShowConfirmNoteL( R_QTN_PASSWORD_REMOVED_TEXT );
-// RefreshDriveInfoL();
-// }
-// }
-//
-//// ------------------------------------------------------------------------------
-//// CFileManagerViewBase::CmdMemoryCardDetailsL
-////
-//// ------------------------------------------------------------------------------
-////
-//void CFileManagerViewBase::CmdMemoryCardDetailsL()
-// {
-// TFileManagerDriveInfo drvInfo;
-// iEngine.GetDriveInfoL( iEngine.CurrentDrive(), drvInfo );
-// FileManagerDlgUtils::ShowMemoryStoreInfoPopupL( drvInfo );
-// }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::UpdatePasswordL
-//
-// ------------------------------------------------------------------------------
-//
-TInt CFileManagerViewBase::UpdatePassword(
- TInt aDrive, const TDesC& aOldPwd, const TDesC& aPwd )
- {
- TMediaPassword mPwdNew;
- TMediaPassword mPwdOld;
-
- ConvertCharsToPwd( aOldPwd, mPwdOld );
- ConvertCharsToPwd( aPwd, mPwdNew );
-
- return iEngine.SetDrivePassword( aDrive, mPwdOld, mPwdNew );
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::UnlockRemovePasswordL
-//
-// ------------------------------------------------------------------------------
-//
-TInt CFileManagerViewBase::UnlockRemovePasswordL(
- TInt aDrive, TBool aRemove )
- {
- TBuf< KFmgrMaxMediaPassword > oldPwd;
- TInt err( KErrNone );
- TMediaPassword pwd;
- TInt res( R_QTN_UNLOCK_PASSWORD_TEXT );
- TInt resWrong( R_QTN_UNLOCK_PWD_WRONG_TEXT );
- HBufC* text = NULL;
-
- if( aRemove )
- {
- // Confirm the action
- if( !FileManagerDlgUtils::ShowConfirmQueryWithYesNoL(
- R_QTN_PASSWORD_REMOVE_TEXT ) )
- {
- return KErrCancel; // Skip the rest if not accepted
- }
- res = R_QTN_PASSWORD_OLD_TEXT;
- resWrong = R_QTN_PASSWORDS_WRONG_TEXT;
- }
- else
- {
- // Just unlock
-#ifdef RD_MULTIPLE_DRIVE
- text = iEngine.GetFormattedDriveNameLC(
- aDrive,
- R_QTN_MEMC_UNLOCK_PASSWORD_MULTIPLE_DEFAULTNAME,
- R_QTN_MEMC_UNLOCK_PASSWORD_MULTIPLE );
-#else // RD_MULTIPLE_DRIVE
- text = StringLoader::LoadLC( R_QTN_UNLOCK_PASSWORD_TEXT );
-#endif // RD_MULTIPLE_DRIVE
- }
-
- // Show until correct pwd is given or canceled
- TBool isDone( EFalse );
- while( !isDone )
- {
- // Empty first
- EmptyPwd( oldPwd );
- TBool pwdGiven( EFalse );
- if ( text )
- {
- pwdGiven = FileManagerDlgUtils::ShowSimplePasswordQueryL( *text, oldPwd );
- }
- else
- {
- pwdGiven = FileManagerDlgUtils::ShowSimplePasswordQueryL( res, oldPwd );
- }
-
- if( pwdGiven )
- {
- ConvertCharsToPwd( oldPwd, pwd );
- if( aRemove )
- {
- err = iEngine.RemoveDrivePassword( aDrive, pwd );
- }
- else
- {
- err = iEngine.UnlockDrive( aDrive, pwd );
- }
-
- if ( err == KErrNone )
- {
- isDone = ETrue;
- }
- else if ( err == KErrAccessDenied )
- {
- FileManagerDlgUtils::ShowErrorNoteL( resWrong );
- }
- else if ( err == KErrNotReady )
- {
- isDone = ETrue;
- FileManagerDlgUtils::ShowErrorNoteL( R_QTN_MEMC_NOT_AVAILABLE );
- }
- else
- {
- isDone = ETrue;
- FileManagerDlgUtils::ShowErrorNoteL( R_QTN_CRITICAL_ERROR );
- }
- }
- else
- {
- err = KErrCancel;
- isDone = ETrue;
- }
- }
-
- if ( text )
- {
- CleanupStack::PopAndDestroy( text );
- }
- return err;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::SetRemoteDriveConnectionStateL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::SetRemoteDriveConnectionStateL( TBool aState )
- {
- TInt drv( 0 );
-
- StoreIndex();
- if ( !iEngine.CurrentDirectory().Length() )
- {
- TInt index( iContainer->ListBoxCurrentItemIndex() );
- CFileManagerItemProperties* prop = iEngine.GetItemInfoL( index );
- CleanupStack::PushL( prop );
- drv = TDriveUnit( prop->FullPath() );
- CleanupStack::PopAndDestroy( prop );
- }
- else
- {
- TFileManagerDriveInfo& drvInfo( DriveInfo() );
- drv = drvInfo.iDrive;
- }
- iEngine.SetRemoteDriveConnection( drv, aState );
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::OpenRemoteDriveSettingsL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::OpenRemoteDriveSettingsL(
- const TDesC& aDriveName )
- {
- CFileManagerAppUi* appUi = static_cast< CFileManagerAppUi* >( AppUi() );
- appUi->ActivateRemoteDriveSettingsViewL( aDriveName );
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::IsDisconnectedRemoteDrive
-//
-// ------------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::IsDisconnectedRemoteDrive(
- CFileManagerItemProperties& aProp )
- {
- TUint32 drvState( 0 );
- if ( iEngine.DriveState( drvState, aProp.FullPath() ) == KErrNone )
- {
- if ( ( drvState & TFileManagerDriveInfo::EDriveRemote ) &&
- !( drvState & TFileManagerDriveInfo::EDriveConnected ) )
- {
- return ETrue;
- }
- }
- return EFalse;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::RemoteDriveCommonFilteringL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::RemoteDriveCommonFilteringL( CEikMenuPane& aMenuPane )
- {
- TBool dimAll( EFalse );
- if ( !FeatureManager().IsRemoteStorageFwSupported() )
- {
- dimAll = ETrue;
- }
- else
- {
-// CEikListBox& listBox = iContainer->ListBox();
- if ( iContainer->ListBoxNumberOfItems() )
- {
- TInt index( iContainer->ListBoxCurrentItemIndex() );
- CFileManagerItemProperties* prop = iEngine.GetItemInfoL( index );
-
- TUint32 drvState( 0 );
- TInt err( iEngine.DriveState( drvState, prop->FullPath() ) );
- if ( err == KErrNone &&
- ( drvState & TFileManagerDriveInfo::EDriveRemote ) )
- {
- if ( drvState & TFileManagerDriveInfo::EDriveConnected )
- {
- aMenuPane.SetItemDimmed( EFileManagerConnectRemoveDrive, ETrue );
- }
- else
- {
- aMenuPane.SetItemDimmed( EFileManagerDisconnectRemoveDrive, ETrue );
- }
- }
- else
- {
- dimAll = ETrue;
- }
- delete prop;
- }
- else
- {
- // List is empty
- TFileManagerDriveInfo& drvInfo( DriveInfo() );
-
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveRemote )
- {
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveConnected )
- {
- aMenuPane.SetItemDimmed( EFileManagerConnectRemoveDrive, ETrue );
- }
- else
- {
- aMenuPane.SetItemDimmed( EFileManagerDisconnectRemoveDrive, ETrue );
- }
- }
- else
- {
- dimAll = ETrue;
- }
- }
- }
-
- if ( dimAll )
- {
- aMenuPane.SetItemDimmed( EFileManagerConnectRemoveDrive, ETrue );
- aMenuPane.SetItemDimmed( EFileManagerDisconnectRemoveDrive, ETrue );
- }
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::LaunchProgressBarL
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::LaunchProgressBarL(
- TInt aDialogId,
- TInt aTextId,
- TInt64 aFinalValue,
- TInt64 aInitialValue,
- TBool aPeriodic,
- TBool aImmediatelyVisible )
- {
- ClearProgressBarL(); // Clear previous
-
- if ( aFinalValue )
- {
- iProgressDialog = new (ELeave) CAknProgressDialog(
- ( reinterpret_cast< CEikDialog** >( &iProgressDialog ) ), aImmediatelyVisible );
- iProgressDialog->PrepareLC( aDialogId );
-
- if ( aPeriodic )
- {
- iPeriodic = CPeriodic::NewL( CActive::EPriorityStandard );
- iPeriodic->Start(
- KProgressBarUpdateInterval, KProgressBarUpdateInterval,
- TCallBack( UpdateProgressBar, this ) );
- }
- }
- else
- {
- iProgressDialog = new (ELeave) CAknWaitDialog(
- ( reinterpret_cast< CEikDialog** >( &iProgressDialog ) ), aImmediatelyVisible );
- iProgressDialog->PrepareLC( aDialogId );
- }
-
- if ( aTextId )
- {
- HBufC* text = StringLoader::LoadLC( aTextId );
- iProgressDialog->SetTextL( *text );
- CleanupStack::PopAndDestroy( text );
- }
-
- iProgressDialog->SetCallback(this);
- iProgressInfo = iProgressDialog->GetProgressInfoL();
- if ( iProgressInfo )
- {
- iProgressInfo->SetFinalValue( static_cast<TInt>( aFinalValue / KMinificationFactor ) );
- iProgressInfo->SetAndDraw( static_cast<TInt>( aInitialValue / KMinificationFactor ) );
- }
- iProgressDialog->RunLD();
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::RefreshProgressDelayedStart
-//
-// ------------------------------------------------------------------------------
-//
-TInt CFileManagerViewBase::RefreshProgressDelayedStart( TAny* aPtr )
- {
- CFileManagerViewBase* view = static_cast< CFileManagerViewBase* > ( aPtr );
- TRAP_IGNORE( view->RefreshProgressDelayedStartL() );
- return KErrNone;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::RefreshProgressDelayedStartL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::RefreshProgressDelayedStartL()
- {
- CFileManagerAppUi* app = static_cast< CFileManagerAppUi* >( AppUi() );
-
- delete iRefreshProgressDelayedStart;
- iRefreshProgressDelayedStart = NULL;
-
- if( iProgressDialogRefresh )
- {
- iProgressDialogRefresh->ProcessFinishedL();
- iProgressDialogRefresh = NULL;
- }
- iProgressDialogRefresh = new( ELeave ) CAknProgressDialog(
- reinterpret_cast< CEikDialog** >( &iProgressDialogRefresh ),
- EFalse );
- iProgressDialogRefresh->SetCallback( this );
-
- if ( Id() == CFileManagerAppUi::KFileManagerSearchResultsViewId )
- {
- iProgressDialogRefresh->ExecuteLD( R_FILEMANAGER_FIND_WAIT_DIALOG );
- }
- else
- {
- iProgressDialogRefresh->ExecuteLD( R_FILEMANAGER_WAIT_NOTE_OPEN );
- }
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::IsRefreshInProgress
-//
-// ------------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::IsRefreshInProgress()
- {
- if ( iRefreshProgressDelayedStart || iProgressDialogRefresh )
- {
- return ETrue;
- }
- return EFalse;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::ProcessCommandL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::ProcessCommandL( TInt aCommand )
- {
- // Suppress commands during refresh
- if ( IsRefreshInProgress() )
- {
- switch ( aCommand )
- {
- case EAknSoftkeyOptions: // FALLTHROUGH
- case EAknSoftkeyBack: // FALLTHROUGH
- case EAknSoftkeyContextOptions: // FALLTHROUGH
- case EAknSoftkeyMark: // FALLTHROUGH
- case EAknSoftkeyUnmark: // FALLTHROUGH
- case EAknSoftkeySelect:
- {
- return;
- }
- default:
- {
- break;
- }
- }
- }
-
- // Handle commands directly
- switch ( aCommand )
- {
- case EAknSoftkeyContextOptions: // FALLTHROUGH
- case EAknSoftkeyMark:
- {
- HandleCommandL( aCommand );
- break;
- }
- default:
- {
- CAknView::ProcessCommandL( aCommand );
- break;
- }
- }
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::AskPathL
-//
-// ------------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::AskPathL( TDes& aPath, TInt aTextId )
- {
- TBool ret( EFalse );
- TInt memType(
- AknCommonDialogsDynMem::EMemoryTypePhone |
- AknCommonDialogsDynMem::EMemoryTypeMMC );
-
- if ( FeatureManager().IsRemoteStorageFwSupported() )
- {
- memType |= AknCommonDialogsDynMem::EMemoryTypeRemote;
- }
-
- HBufC* title = StringLoader::LoadLC( aTextId );
- CFileManagerFileSelectionFilter* filter =
- new( ELeave ) CFileManagerFileSelectionFilter( iEngine );
- CleanupStack::PushL( filter );
-
- ret = AknCommonDialogsDynMem::RunFolderSelectDlgLD(
- memType,
- aPath,
- KNullDesC,
- R_FILEMANAGER_FIND_MEMORY_SELECTIONDIALOG,
- R_FILEMANAGER_FIND_FOLDER_SELECTIONDIALOG,
- *title,
- filter );
-
- CleanupStack::PopAndDestroy( filter );
- CleanupStack::PopAndDestroy( title );
- return ret;
- }
-
-#ifdef RD_FILE_MANAGER_BACKUP
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::StartSchBackupL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::StartSchBackupL()
- {
- FUNC_LOG
-
- CFileManagerAppUi* appUi = static_cast< CFileManagerAppUi* >( AppUi() );
- CFileManagerSchBackupHandler& handler( appUi->SchBackupHandlerL() );
-
- if ( FeatureManager().IsFeatureSupported(
- EFileManagerFeatureScheduledBackupDisabled ) )
- {
- // Scheduled backup is disabled, disable scheduler and cancel backup
- INFO_LOG( "CFileManagerViewBase::StartSchBackupL-Backup disabled" )
-
- handler.CancelBackupStarter();
- CFileManagerTaskScheduler& scheduler( appUi->TaskSchedulerL() );
- scheduler.EnableBackupScheduleL( EFalse );
- appUi->SchBackupFinishedL( KErrCancel );
- return;
- }
-
- // Start scheduled backup if no process in progress
- // Otherwise wait process to finish
- if ( iActiveProcess == ENoProcess )
- {
- CFileManagerBackupSettings& settings( iEngine.BackupSettingsL() );
- TTime schTime( SetCurrentYearMonthAndDay( settings.Time() ) );
-
- TTime manualBackupOrRestoreStarted = appUi->BackupOrRestoreStartTime();
- TTime manualBackupOrRestoreEnded = appUi->BackupOrRestoreEndTime();
-
- if ( manualBackupOrRestoreStarted.Int64() > 0 &&
- schTime >= manualBackupOrRestoreStarted &&
- schTime <= manualBackupOrRestoreEnded )
- {
- INFO_LOG( "CFileManagerViewBase::StartSchBackupL-Backup canceled due to manual op" )
-
- handler.CancelBackupStarter();
-
- appUi->ResetBackupOrRestoreEndTime();// Cancel required only once
- }
- else
- {
- INFO_LOG( "CFileManagerViewBase::StartSchBackupL-Start backup" )
-
- iSchBackupPending = EFalse;
- iActiveProcess = ESchBackupProcess;
- iEngine.SetObserver( this );
- handler.StartBackupWithConfirm();
- }
- }
- // Ignore scheduled backup if backup or restore is in progress
- else if ( iActiveProcess == ESchBackupProcess ||
- iActiveProcess == EBackupProcess ||
- iActiveProcess == ERestoreProcess )
- {
- INFO_LOG( "CFileManagerViewBase::StartSchBackupL-Backup canceled" )
-
- handler.CancelBackupStarter();
- }
- else
- {
- INFO_LOG( "CFileManagerViewBase::StartSchBackupL-Backup pending" )
-
- iSchBackupPending = ETrue;
- }
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::SchBackupFinishedL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::SchBackupFinishedL()
- {
- FUNC_LOG
-
- if ( iActiveProcess == ESchBackupProcess )
- {
- iActiveProcess = ENoProcess;
- iSchBackupPending = EFalse;
- }
- }
-
-#endif // RD_FILE_MANAGER_BACKUP
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::SetCbaMskTextL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::SetCbaMskTextL( const TInt aTextId )
- {
- HBufC* text = StringLoader::LoadLC( aTextId );
- CEikButtonGroupContainer* cba = Cba();
- if ( cba->ButtonCount() == KFmgrMSK )
- {
- TInt cmdId( cba->ButtonGroup()->CommandId( KFmgrMSK ) );
- cba->SetCommandL( KFmgrMSK, cmdId, *text );
- cba->DrawDeferred();
- }
- CleanupStack::PopAndDestroy( text );
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::UpdateCbaL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::UpdateCbaL()
- {
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::UpdateCommonCbaL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::UpdateCommonCbaL()
- {
- if ( !iContainer || IsRefreshInProgress() )
- {
- return;
- }
-
- CEikButtonGroupContainer* cba = Cba();
-
- if ( !iContainer->ListBoxNumberOfItems() )
- {
- cba->SetCommandSetL(
- R_FILEMANAGER_SOFTKEYS_OPTIONS_BACK__EMPTY );
- }
- else if ( iContainer->ListBoxSelectionIndexesCount() )
- {
- cba->SetCommandSetL(
- R_FILEMANAGER_SOFTKEYS_CONTEXT_OPTIONS_BACK__OPTIONS );
- }
- else
- {
- cba->SetCommandSetL(
- R_FILEMANAGER_SOFTKEYS_OPTIONS_BACK__OPEN );
- }
-
- // Restore right cancel softkey if it has been set by search field
- TBool restoreCancel( ETrue );
- if ( iContainer->IsSearchFieldVisible() &&
- cba->ButtonCount() >= CEikButtonGroupContainer::ERightSoftkeyPosition )
- {
- restoreCancel = ( cba->ButtonGroup()->CommandId(
- CEikButtonGroupContainer::ERightSoftkeyPosition ) == EAknSoftkeyCancel );
- }
- if ( !restoreCancel )
- {
- HBufC* cancelText = StringLoader::LoadLC( R_AVKON_SOFTKEY_CANCEL );
- cba->SetCommandL(
- CEikButtonGroupContainer::ERightSoftkeyPosition,
- EAknSoftkeyCancel,
- *cancelText );
- CleanupStack::PopAndDestroy( cancelText );
- }
-
- cba->DrawDeferred();
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::RenameDriveL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::RenameDriveL( TBool aForceDefaultName )
- {
- TFileManagerDriveInfo drvInfo;
- if ( DriveInfoAtCurrentPosL( drvInfo ) < 0 )
- {
- return; // No drive selected
- }
-
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveMassStorage )
- {
- return; // Name not allowed
- }
-
- HBufC* drvName = HBufC::NewLC( KMaxVolumeName );
- TPtr name( drvName->Des() );
- // 16-bit chars are required for non western volume names
- const TInt KMaxNonWesternVolumeName( KMaxVolumeName / 2 );
-
- // Setup query according to variant type, western or non western
- TInt resId( R_FILEMANAGER_DRIVE_NAME_QUERY );
- TInt maxLen( KMaxVolumeName );
- if ( !FeatureManager().IsWesternVariant() )
- {
- resId = R_FILEMANAGER_DRIVE_NAME_QUERY_NON_WESTERN;
- maxLen = KMaxNonWesternVolumeName;
- }
-
- if ( aForceDefaultName || !drvInfo.iName.Length() )
- {
- HBufC* defaultName = NULL;
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveUsbMemory )
- {
- defaultName = StringLoader::LoadLC(
- R_QTN_FMGR_USB_MEMORY_DEFAULT_NAME );
- }
- else
- {
- defaultName = StringLoader::LoadLC( R_QTN_MMC_DEFAULT_NAME );
- }
- if ( defaultName->Length() > maxLen )
- {
- name.Copy( defaultName->Des().Left( maxLen ) );
- }
- else
- {
- name.Copy( *defaultName );
- }
- CleanupStack::PopAndDestroy( defaultName );
- }
- else
- {
- if ( drvInfo.iName.Length() > maxLen )
- {
- name.Copy( drvInfo.iName.Left( maxLen ) );
- }
- else
- {
- name.Copy( drvInfo.iName );
- }
- }
-
- // Loop until canceled, accepted or an error occurs
- TBool isDone( EFalse );
- while( !isDone )
- {
- CAknTextQueryDialog* renameDlg =
- CAknTextQueryDialog::NewL( name, CAknQueryDialog::ENoTone );
- renameDlg->SetMaxLength( maxLen );
- TBool ret( EFalse );
- if ( renameDlg->ExecuteLD( resId ) )
- {
- ret = ETrue;
- }
- if( ret && name.Compare( drvInfo.iName ) )
- {
- TInt err( iEngine.RenameDrive( drvInfo.iDrive, name ) );
- if( err == KErrNone )
- {
- FileManagerDlgUtils::ShowConfirmNoteL(
- R_QTN_FMGR_CONFIRM_MEMORY_NAME_CHANGED );
- RefreshDriveInfoL();
- isDone = ETrue;
- }
- else if( err == KErrBadName )
- {
- FileManagerDlgUtils::ShowInfoNoteL(
- R_QTN_INVALID_DRIVE_NAME );
- }
- else
- {
- FileManagerDlgUtils::ShowErrorNoteL(
- R_QTN_CRITICAL_ERROR );
- isDone = ETrue;
- }
- }
- else
- {
- // Canceled
- isDone = ETrue;
- }
- }
- CleanupStack::PopAndDestroy( drvName );
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::CmdRefreshDirectoryL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::CmdRefreshDirectoryL()
- {
- StoreIndex();
- iEngine.SetObserver( this );
- iEngine.ForcedRefreshDirectory();
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::ShowEjectQueryL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerViewBase::ShowEjectQueryL()
- {
- delete iEjectQueryDialog;
- iEjectQueryDialog = NULL;
-
- iEjectDone = EFalse;
- iEjectQueryDialog = CAknQueryDialog::NewL();
- HBufC* text = NULL;
- TInt index( iContainer->ListBoxCurrentItemIndex() );
- CFileManagerItemProperties* prop = iEngine.GetItemInfoLC( index );
-#ifdef RD_MULTIPLE_DRIVE
- text = iEngine.GetFormattedDriveNameLC(
- prop->DriveId(),
- R_QTN_MEMC_INFO_EJECT_MULTIPLE_DEFAULTNAME,
- R_QTN_MEMC_INFO_EJECT_MULTIPLE );
-#else // RD_MULTIPLE_DRIVE
- text = StringLoader::LoadLC( R_QTN_INFO_EJECT );
-#endif // RD_MULTIPLE_DRIVE
- TRAP_IGNORE( iEjectQueryDialog->ExecuteLD(
- R_FILEMANAGER_EJECT_CONFIRM_QUERY, *text ) );
- CleanupStack::PopAndDestroy( text );
- CleanupStack::PopAndDestroy( prop );
- iEjectQueryDialog = NULL;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::IsDriveAvailable
-//
-// ------------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::IsDriveAvailable( const TDesC& aPath ) const
- {
- TBool ret( EFalse );
- if ( aPath.Length() )
- {
- TInt drive = TDriveUnit( aPath );
- ret = IsDriveAvailable( drive );
- }
- return ret;
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::IsDriveAvailable
-//
-// ------------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::IsDriveAvailable( const TInt aDrive ) const
- {
- TUint32 drvState( 0 );
- if ( iEngine.DriveState( drvState, aDrive ) != KErrNone )
- {
- return EFalse;
- }
- if ( drvState & ( TFileManagerDriveInfo::EDriveLocked |
- TFileManagerDriveInfo::EDriveCorrupted |
- TFileManagerDriveInfo::EDriveInUse ) )
- {
- return EFalse; // Drive is unavailable
- }
- if ( !( drvState & TFileManagerDriveInfo::EDriveRemote ) &&
- !( drvState & TFileManagerDriveInfo::EDrivePresent ) )
- {
- return EFalse; // Drive is not present
- }
- return ETrue;
- }
-
-// ----------------------------------------------------------------------------
-// CFileManagerViewBase::CheckPhoneState
-//
-// ----------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::CheckPhoneState() const
- {
- // Check here all operations, which are supposed
- // to prevent manual backup or restore.
- TBool err( ETrue );
- TInt syncErr( 0 );
- TInt syncStat( 0 );
- TInt burErr( 0 );
- TInt burStat( 0 );
-
- // Check synchronization state
- syncErr = RProperty::Get(
- KPSUidDataSynchronizationInternalKeys,
- KDataSyncStatus, syncStat );
-
- // Check backup/restore (e.g. PC Suite initiated) state
- burErr = RProperty::Get(
- KUidSystemCategory,
- KUidBackupRestoreKey, burStat );
- const TBURPartType partType = static_cast< TBURPartType >
- ( burStat & KBURPartTypeMask );
-
- if ( (syncErr == KErrNone && syncStat > 0)
- || (burErr == KErrNone && partType != EBURUnset && partType != EBURNormal ) )
- {
- err = EFalse;
- }
-
- return err;
- }
-
-// ----------------------------------------------------------------------------
-// CFileManagerViewBase::StopProgressDialogAndStoreValues
-//
-// ----------------------------------------------------------------------------
-//
-TBool CFileManagerViewBase::StopProgressDialogAndStoreValues()
- {
- TBool ret( EFalse );
- if ( iProgressDialog && iProgressInfo )
- {
- CEikProgressInfo::SInfo info( iProgressInfo->Info() );
- iProgressFinalValue = ( info.iFinalValue ) * KMinificationFactor;
- iProgressCurrentValue = ( iProgressInfo->CurrentValue() ) * KMinificationFactor;
- if ( !iProgressCurrentValue && iTotalTransferredBytes <= iProgressFinalValue )
- {
- iProgressCurrentValue = iTotalTransferredBytes;
- }
- TRAP_IGNORE( iProgressDialog->ProcessFinishedL() );
- iProgressDialog = NULL;
- iProgressInfo = NULL;
- ret = ETrue;
- }
-
- delete iRefreshProgressDelayedStart;
- iRefreshProgressDelayedStart = NULL;
- delete iPeriodic;
- iPeriodic = NULL;
-
- return ret;
- }
-
-
-// ----------------------------------------------------------------------------
-// CFileManagerViewBase::CheckPostponedDirectoryRefresh
-//
-// ----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::CheckPostponedDirectoryRefresh()
- {
- if ( iDirectoryRefreshPostponed )
- {
- // Delete was canceled but directory was changed during query
- StoreIndex();
- iEngine.SetObserver( this );
- iEngine.RefreshDirectory();
- }
- iDirectoryRefreshPostponed = EFalse;
- }
-
-// ----------------------------------------------------------------------------
-// CFileManagerViewBase::DenyDirectoryRefresh
-//
-// ----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::DenyDirectoryRefresh( TBool aDeny )
- {
- iDirectoryRefreshDenied = aDeny;
- if ( aDeny )
- {
- iDirectoryRefreshPostponed = EFalse; // Reset previous value
- }
- }
-
-// ----------------------------------------------------------------------------
-// CFileManagerViewBase::SortMenuFilteringL
-//
-// ----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::SortMenuFilteringL( CEikMenuPane& aMenuPane )
- {
- TInt selected( EFileManagerSortByName );
- switch ( iEngine.SortMethod() )
- {
- case CFileManagerEngine::EByMatch:
- {
- if ( iEngine.State() == CFileManagerEngine::ESearch )
- {
- selected = EFileManagerSortByMatch;
- }
- break;
- }
- case CFileManagerEngine::EByName:
- {
- selected = EFileManagerSortByName;
- break;
- }
- case CFileManagerEngine::EByType:
- {
- selected = EFileManagerSortByType;
- break;
- }
- case CFileManagerEngine::EMostRecentFirst:
- {
- selected = EFileManagerSortMostRecentFirst;
- break;
- }
- case CFileManagerEngine::ELargestFirst:
- {
- selected = EFileManagerSortLargestFirst;
- break;
- }
- default:
- {
- break;
- }
- }
- TInt position = 0;
- if ( aMenuPane.MenuItemExists( selected, position ) )
- {
- aMenuPane.SetItemButtonState( selected, EEikMenuItemSymbolOn );
- }
- }
-
-// ----------------------------------------------------------------------------
-// CFileManagerViewBase::CmdSortL
-//
-// ----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::CmdSortL( TInt aCommand )
- {
- CFileManagerEngine::TSortMethod sortMethod( CFileManagerEngine::EByName );
- switch ( aCommand )
- {
- case EFileManagerSortByName:
- {
- sortMethod = CFileManagerEngine::EByName;
- break;
- }
- case EFileManagerSortByType:
- {
- sortMethod = CFileManagerEngine::EByType;
- break;
- }
- case EFileManagerSortMostRecentFirst:
- {
- sortMethod = CFileManagerEngine::EMostRecentFirst;
- break;
- }
- case EFileManagerSortLargestFirst:
- {
- sortMethod = CFileManagerEngine::ELargestFirst;
- break;
- }
- case EFileManagerSortByMatch:
- {
- sortMethod = CFileManagerEngine::EByMatch;
- break;
- }
- default:
- {
- return;
- }
- }
- if ( iEngine.SortMethod() != sortMethod )
- {
- iIndex = 0;
- if ( iContainer )
- {
- iContainer->SetCurrentItemIndexAfterSearch( 0 );
- }
- iEngine.SetCurrentIndex( 0 );
- iEngine.SetSortMethod( sortMethod );
- iEngine.RefreshSort();
- }
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::FeatureManager
-//
-// -----------------------------------------------------------------------------
-//
-CFileManagerFeatureManager& CFileManagerViewBase::FeatureManager() const
- {
- return iEngine.FeatureManager();
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::NotifyForegroundStatusChange
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::NotifyForegroundStatusChange( TBool /*aForeground*/ )
- {
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::ShowDiskSpaceErrorL
-//
-// -----------------------------------------------------------------------------
-//
-#ifdef RD_MULTIPLE_DRIVE
-
-void CFileManagerViewBase::ShowDiskSpaceErrorL( const TDesC& aFolder )
- {
- TInt defaultNameResId( 0 );
- TInt namedResId( 0 );
- TInt drv( KErrNotFound );
- if ( aFolder.Length() )
- {
- TFileManagerDriveInfo drvInfo;
- drv = TDriveUnit( aFolder );
- iEngine.GetDriveInfoL( drv, drvInfo );
- if ( drvInfo.iState & TFileManagerDriveInfo::EDriveMassStorage )
- {
- defaultNameResId = R_QTN_MEMLO_NOT_ENOUGH_MASS_MEMORY;
- }
- else if ( drvInfo.iState & TFileManagerDriveInfo::EDriveUsbMemory )
- {
- defaultNameResId = R_QTN_MEMLO_NOT_ENOUGH_MEMORY_CARD_NAME;
- namedResId = R_QTN_MEMLO_NOT_ENOUGH_MEMORY_CARD_NAME;
- }
- else if ( drvInfo.iState & TFileManagerDriveInfo::EDriveRemovable )
- {
- defaultNameResId = R_QTN_MEMLO_NOT_ENOUGH_MEMORY_CARD_DEFAULTNAME;
- namedResId = R_QTN_MEMLO_NOT_ENOUGH_MEMORY_CARD_NAME;
- }
- else if ( !( drvInfo.iState & TFileManagerDriveInfo::EDriveRemote ) )
- {
- defaultNameResId = R_QTN_MEMLO_NOT_ENOUGH_DEVICE_MEMORY;
- }
- }
- if ( defaultNameResId )
- {
- HBufC* text = iEngine.GetFormattedDriveNameLC(
- drv, defaultNameResId, namedResId );
- FileManagerDlgUtils::ShowConfirmQueryWithOkL(
- FileManagerDlgUtils::EErrorIcons, *text );
- CleanupStack::PopAndDestroy( text );
- }
- else
- {
- Error( KErrDiskFull ); // Show general error
- }
- }
-
-#else // RD_MULTIPLE_DRIVE
-
-void CFileManagerViewBase::ShowDiskSpaceErrorL( const TDesC& /*aFolder*/ )
- {
- Error( KErrDiskFull ); // Show general error
- }
-
-#endif // RD_MULTIPLE_DRIVE
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::DoLaunchProgressDialogAsync
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::DoLaunchProgressDialogAsync()
- {
- // Store the bytes value to be restored after new launch
- TInt64 prevBytes = iTotalTransferredBytes;
-
- // Ensure that current progress value is up to date
- if ( iTotalTransferredBytes > iProgressCurrentValue &&
- iTotalTransferredBytes <= iProgressFinalValue )
- {
- iProgressCurrentValue = iTotalTransferredBytes;
- }
-
- TRAP_IGNORE( LaunchProgressDialogL(
- iProgressFinalValue, iProgressCurrentValue, iActiveProcess, ETrue ) );
-
- iTotalTransferredBytes = prevBytes;
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::LaunchProgressDialogAsync
-//
-// -----------------------------------------------------------------------------
-//
-TInt CFileManagerViewBase::LaunchProgressDialogAsync( TAny* aPtr )
- {
- static_cast< CFileManagerViewBase* >( aPtr )->DoLaunchProgressDialogAsync();
- return KErrNone;
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::FilesCountInSearchField()
-//
-// -----------------------------------------------------------------------------
-//
-TInt CFileManagerViewBase::FilesCountInSearchField()
- {
- TInt count = 0;
-
- if( iContainer->IsSearchFieldVisible() )
- {
- TInt listBoxIndex =0;
- for(TInt i(0); i<iContainer->ListBoxNumberOfItems();i++ )
- {
- listBoxIndex = iContainer->SearchFieldToListBoxIndex( i );
- if( !iEngine.IsFolder( listBoxIndex ) )
- {
- count++;
- }
- }
- }
- return count;
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::HandleServerAppExit
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::HandleServerAppExit( TInt /*aReason*/ )
- {
- iEngine.SetAppExitOb( NULL );
- iEngine.SetObserver( this );
- iEngine.RefreshDirectory();
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::EmptyPwd
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::EmptyPwd( TDes& aPwd )
- {
- aPwd.FillZ( aPwd.MaxLength( ) );
- aPwd.Zero();
- }
-
-// -----------------------------------------------------------------------------
-// CFileManagerViewBase::ConvertCharsToPwd
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerViewBase::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 );
- }
- }
-
-// ------------------------------------------------------------------------------
-// CFileManagerViewBase::DriveInfoAtCurrentPosL
-//
-// ------------------------------------------------------------------------------
-//
-TInt CFileManagerViewBase::DriveInfoAtCurrentPosL(
- TFileManagerDriveInfo& aInfo )
- {
- TUid viewId( Id() );
- if ( viewId == CFileManagerAppUi::KFileManagerMemoryStoreViewId ||
- viewId == CFileManagerAppUi::KFileManagerFoldersViewId )
- {
- INFO_LOG1("CFileManagerViewBase::DriveInfoAtCurrentPosL viewId=%D", viewId.iUid)
- // Use cached info
- aInfo = DriveInfo();
- return aInfo.iDrive;
- }
-
- // Fetch info
- if ( !iContainer )
- {
- return KErrNotFound;
- }
- if ( !iContainer->ListBoxNumberOfItems() )
- {
- return KErrNotFound;
- }
- CFileManagerItemProperties* prop = iEngine.GetItemInfoLC(
- iContainer->ListBoxCurrentItemIndex() );
- TInt ret( KErrNotFound );
- TPtrC fullPath( prop->FullPath() );
- if ( fullPath.Length() )
- {
- ret = TDriveUnit( fullPath );
- iEngine.GetDriveInfoL( ret, aInfo );
- }
- CleanupStack::PopAndDestroy( prop );
- return ret;
- }
-
-// End of File