/*
* Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0""
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Base class for all file manager views
*
*/
// INCLUDE FILES
#include <aknlists.h>
#include <eikmenup.h> // CEikMenuPane
#include <eikmenub.h> // CEikMenuBar
#include <StringLoader.h>
#include <AknCommonDialogs.h> // Common File Dialogs
#include <CAknMemorySelectionDialog.h>
#include <CAknFileSelectionDialog.h>
#include <sendui.h>
#include <Sendnorm.rsg>
#include <SenduiMtmUids.h>
#include <AknProgressDialog.h>
#include <eikprogi.h>
#include <AknWaitNoteWrapper.h>
#include <aknnotewrappers.h>
#include <AknWaitDialog.h>
#include <cmemstatepopup.h>
#include <f32file.h>
#include <aknmessagequerydialog.h>
#include <CMessageData.h>
#include <DRMHelper.h>
#include <bautils.h>
#include <AknCommonDialogsDynMem.h>
#include "CFileManagerViewBase.h"
#include "CFileManagerContainerBase.h"
#include "CFileManagerAppUi.h"
#include "CFileManagerDocument.h"
#include "CFileManagerFileSelectionFilter.h"
#include "FileManager.hrh"
#ifdef RD_FILE_MANAGER_BACKUP
#include "CFileManagerSchBackupHandler.h"
#include "CFileManagerBackupSettings.h"
#include "CFileManagerTaskScheduler.h"
#endif // RD_FILE_MANAGER_BACKUP
#include <CFileManagerEngine.h>
#include <CFileManagerUtils.h>
#include <CFileManagerCommonDefinitions.h>
#include <CFileManagerItemProperties.h>
#include <CFileManagerActiveExecute.h>
#include <Cfilemanageractivedelete.h>
#include <FileManager.rsg>
#include <FileManagerView.rsg>
#include <FileManagerDebug.h>
#include <FileManagerDlgUtils.h>
#include <CFileManagerFeatureManager.h>
#include <FileManagerPrivateCRKeys.h>
#include <DataSyncInternalPSKeys.h>
#include <connect/sbdefs.h>
#include <e32property.h>
#include <caf/caf.h>
#include <drmagents.h>
using namespace conn;
// CONSTANTS
const TUint KMessageSize = 1024;
const TUint KMaxPercentage = 100;
const TUint KProgressBarUpdateInterval = 1000000; // microseconds
const TUint KDriveLetterSize = 1;
const TUint KRefreshProgressStartDelay = 1000000; // microseconds
const TInt KFmgrMSK = 3;
const TInt KEstimateUpperLimit = 90; // User selectable continuation
const TInt KEstimateLowerLimit = 10; // Backup will be interrupted
const TUint32 KDefaultFolderMask = CFileManagerItemProperties::EFolder |
CFileManagerItemProperties::EDefault;
const TInt64 KMSecToMicroSecMultiplier = 1000000;
const TInt64 KMinToMicroSecMultiplier = KMSecToMicroSecMultiplier * 60;
const TInt64 KHourToMicroSecMultiplier = KMinToMicroSecMultiplier * 60;
const TUint KProgressBarAsyncStartDelay = 1500000; // microseconds
// ============================ LOCAL FUNCTIONS ================================
// -----------------------------------------------------------------------------
// IsWmDrmFile
//
// -----------------------------------------------------------------------------
//
static TBool IsWmDrmFile( const TDesC& aFullPath )
{
TBool ret( EFalse );
ContentAccess::CContent* content = NULL;
TRAPD( err, content = ContentAccess::CContent::CContent::NewL(
aFullPath, EContentShareReadWrite ) );
if ( err != KErrNone )
{
TRAP( err, content = ContentAccess::CContent::CContent::NewL(
aFullPath, EContentShareReadOnly ) );
}
if ( err == KErrNone )
{
TInt isProtected( 0 );
err = content->GetAttribute( EIsProtected, isProtected );
if ( err == KErrNone && isProtected )
{
TInt fileType( 0 );
err = content->GetAttribute( DRM::EDrmFileType, fileType );
ret = ( err == KErrNone && fileType == DRM::EDrmWMFile );
}
delete content;
}
return ret;
}
// -----------------------------------------------------------------------------
// Int64ToInt
//
// -----------------------------------------------------------------------------
//
static TInt Int64ToInt( const TInt64& aInt64 )
{
if ( aInt64 > KMaxTInt )
{
return KMaxTInt;
}
return I64INT( aInt64 );
}
// -----------------------------------------------------------------------------
// EmptyPwd
//
// -----------------------------------------------------------------------------
//
//static void EmptyPwd( TDes& aPwd )
// {
// aPwd.FillZ( aPwd.MaxLength( ) );
// aPwd.Zero();
// }
// -----------------------------------------------------------------------------
// ConvertCharsToPwd
//
// -----------------------------------------------------------------------------
//
//static void ConvertCharsToPwd( const TDesC& aWord, TDes8& aConverted )
// {
// // Make sure the target password is empty ( can't use the function here )
// aConverted.FillZ( aConverted.MaxLength() );
// aConverted.Zero();
// TInt size( aWord.Size() );
// if ( size )
// {
// if ( size > aConverted.MaxLength() )
// {
// size = aConverted.MaxLength();
// }
// aConverted.Copy( (TUint8*)aWord.Ptr(), size );
// }
// }
// -----------------------------------------------------------------------------
// IsSystemProcess
//
// -----------------------------------------------------------------------------
//
static TBool IsSystemProcess(
MFileManagerProcessObserver::TFileManagerProcess aProcess )
{
switch ( aProcess )
{
case MFileManagerProcessObserver::EFormatProcess:
case MFileManagerProcessObserver::EBackupProcess:
case MFileManagerProcessObserver::ERestoreProcess:
case MFileManagerProcessObserver::ESchBackupProcess:
{
return ETrue;
}
default:
{
break;
}
}
return EFalse;
}
// -----------------------------------------------------------------------------
// GetDeleteQueryPromptLC
// Chooses correct string for the delete note
// -----------------------------------------------------------------------------
//
static HBufC* GetDeleteQueryPromptLC( CFileManagerItemProperties& aProp, TInt aCount )
{
HBufC* prompt = NULL;
if ( aCount == 0 && aProp.ContainsAnyFilesOrFolders() )
{
prompt = StringLoader::LoadLC( R_QTN_FLDR_DEL_FULL_FLDRS_QUERY );
}
else if ( aCount <= 1 )
{
prompt = StringLoader::LoadLC( R_QTN_QUERY_COMMON_CONF_DELETE, aProp.NameAndExt() );
}
else // aCount > 1
{
prompt = StringLoader::LoadLC( R_QTN_FLDR_DEL_ITEMS_QUERY, aCount );
}
return prompt;
}
// -----------------------------------------------------------------------------
// MinIndex
//
// -----------------------------------------------------------------------------
//
static TInt MinIndex( CArrayFixFlat<TInt>& aIndexArray )
{
TInt count( aIndexArray.Count() );
if ( !count )
{
return 0;
}
// Find min index
TInt index( 0 );
TInt i( 0 );
TInt ret( aIndexArray.At( i ) );
++i;
for( ; i < count; ++i )
{
index = aIndexArray.At( i );
if ( index < ret )
{
ret = index;
}
}
return ret;
}
// -----------------------------------------------------------------------------
// SetCurrentYearMonthAndDay
//
// -----------------------------------------------------------------------------
//
static TTime SetCurrentYearMonthAndDay( const TTime& aTime )
{
TTime timeNow;
timeNow.HomeTime();
TDateTime dateTimeNow( timeNow.DateTime() );
TInt64 ret( timeNow.Int64() );
// Replace hours, minutes and seconds using given ones.
ret -= static_cast< TInt64 >( dateTimeNow.Hour() ) * KHourToMicroSecMultiplier;
ret -= static_cast< TInt64 >( dateTimeNow.Minute() ) * KMinToMicroSecMultiplier;
ret -= static_cast< TInt64 >( dateTimeNow.Second() ) * KMSecToMicroSecMultiplier;
ret -= dateTimeNow.MicroSecond();
TDateTime dateTime( aTime.DateTime() );
ret += static_cast< TInt64 >( dateTime.Hour() ) * KHourToMicroSecMultiplier;
ret += static_cast< TInt64 >( dateTime.Minute() ) * KMinToMicroSecMultiplier;
ret += static_cast< TInt64 >( dateTime.Second() ) * KMSecToMicroSecMultiplier;
return ret;
}
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CFileManagerViewBase::CFileManagerViewBase
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CFileManagerViewBase::CFileManagerViewBase() :
iEngine( static_cast< CFileManagerDocument* >( AppUi()->Document() )->Engine() )
{
}
// -----------------------------------------------------------------------------
// CFileManagerViewBase::~CFileManagerViewBase
// Destructor
// -----------------------------------------------------------------------------
//
CFileManagerViewBase::~CFileManagerViewBase()
{
delete iWaitNoteWrapper;
delete iActiveDelete;
delete iPeriodic;
delete iMarkedArray;
delete iContainer;
delete iActiveExec;
delete iRefreshProgressDelayedStart;
delete iEjectQueryDialog;
}
// -----------------------------------------------------------------------------
// CFileManagerViewBase::GetSendFilesLC
//
// -----------------------------------------------------------------------------
//
CArrayFixFlat<TInt>* CFileManagerViewBase::GetSendFilesLC( TInt& aSize )
{
// Get index array and remove folders and play lists
CArrayFixFlat< TInt >* ret = MarkedArrayLC();
TInt i( ret->Count() );
while ( i > 0 )
{
--i;
// IconIdL() is slow if the icon is not cached yet.
// However, it is faster than FileTypeL().
switch ( iEngine.IconIdL( ret->At( i ) ) )
{
case EFileManagerFolderIcon: // FALLTHROUGH
case EFileManagerFolderSubIcon: // FALLTHROUGH
case EFileManagerFolderEmptyIcon: // FALLTHROUGH
case EFileManagerPlaylistFileIcon:
{
ret->Delete( i );
break;
}
default:
{
break;
}
}
}
aSize = Int64ToInt( iEngine.GetFileSizesL( *ret ) );
return ret;
}
// -----------------------------------------------------------------------------
// CFileManagerViewBase::ConstructL
//
// -----------------------------------------------------------------------------
//
void CFileManagerViewBase::ConstructL( TInt aResId )
{
BaseConstructL( aResId );
}
// -----------------------------------------------------------------------------
// CFileManagerViewBase::HandleCommandL
//
// -----------------------------------------------------------------------------
//
void CFileManagerViewBase::HandleCommandL( TInt aCommand )
{
if ( !iContainer ) return;
TBool updateCba( !iContainer->SelectionModeEnabled() );
switch( aCommand )
{
case EFileManagerOpen:
{
CmdOpenL();
break;
}
case EFileManagerDelete:
{
CmdDeleteL();
break;
}
case EFileManagerMoveToFolder:
{
CmdMoveToFolderL();
break;
}
case EFileManagerCopyToFolder:
{
CmdCopyToFolderL();
break;
}
case EFileManagerNewFolder:
{
CmdNewFolderL();
break;
}
case EFileManagerMarkOne: // FALLTHROUGH
case EFileManagerUnmarkOne: // FALLTHROUGH
case EFileManagerToggleMark:
{
CmdToggleMarkL();
break;
}
case EFileManagerMarkAll:
{
CmdMarkAllL();
break;
}
case EFileManagerUnmarkAll:
{
CmdUnmarkAllL();
break;
}
case EFileManagerRename:
{
CmdRenameL();
break;
}
case EFileManagerFindFile:
{
CmdFindL();
break;
}
case EFileManagerFileDetails: // FALLTHROUGH
case EFileManagerFolderDetails: // FALLTHROUGH
case EFileManagerViewInfo:
{
CmdViewInfoL();
break;
}
// case EFileManagerMemoryState:
// {
// CmdMemoryStateL();
// break;
// }
case EFileManagerReceiveViaIR:
{
CmdReceiveViaIRL();
break;
}
case EFileManagerCheckMark: // Suppress
{
break;
}
case EAknSoftkeyContextOptions: // FALLTHROUGH
case EFileManagerSelectionKey:
{
TInt count( iContainer->ListBoxSelectionIndexesCount() );
if ( !count )
{
HandleCommandL( EFileManagerOpen );
}
else if ( count > 0 )
{
ShowContextSensitiveMenuL();
}
break;
}
case EFileManagerSend:
{
if ( !iSendUiPopupOpened )
{
SendUiQueryL();
}
break;
}
case EFileManagerMoreInfoOnline:
{
OpenInfoUrlL( iContainer->ListBoxCurrentItemIndex() );
break;
}
case EFileManagerUnlockMemoryCard:
{
CmdUnlockDriveL();
break;
}
// case EFileManagerMemoryCardName:
// case EFileManagerMemoryCardRename: // Fall through
// {
// CmdRenameDriveL();
// break;
// }
//case EFileManagerMemoryCardFormat:
case EFileManagerMemoryStorageFormat:
case EFileManagerFormatMassStorage: // Fall through
{
CmdFormatDriveL();
break;
}
// case EFileManagerMemoryCardPasswordSet:
// {
// CmdSetDrivePasswordL();
// break;
// }
// case EFileManagerMemoryCardPasswordChange:
// {
// CmdChangeDrivePasswordL();
// break;
// }
// case EFileManagerMemoryCardPasswordRemove:
// {
// CmdRemoveDrivePasswordL();
// break;
// }
// case EFileManagerMemoryCardDetails:
// {
// CmdMemoryCardDetailsL();
// break;
// }
case EFileManagerConnectRemoveDrive:
{
SetRemoteDriveConnectionStateL( ETrue );
break;
}
case EFileManagerDisconnectRemoveDrive:
{
SetRemoteDriveConnectionStateL( EFalse );
break;
}
case EFileManagerRefreshRemoteDrive:
{
CmdRefreshDirectoryL();
break;
}
case EFileManagerSortByName:
case EFileManagerSortByType: // Fall through
case EFileManagerSortMostRecentFirst: // Fall through
case EFileManagerSortLargestFirst: // Fall through
case EFileManagerSortByMatch: // Fall through
{
CmdSortL( aCommand );
break;
}
default:
{
AppUi()->HandleCommandL( aCommand );
break;
}
}
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
sendUi.ShowQueryAndSendL( msgData, caps, servicesToDim );
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( 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 )
{
DeleteItemsL( index );
}
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:
{
RefreshDriveInfoL();
if ( aError == KErrNone )
{
#ifdef RD_MULTIPLE_DRIVE
if ( DriveInfo().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();
}
}
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/1024 );
}
}
// ------------------------------------------------------------------------------
// 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 );
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() );
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 );
}
// 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 );
}
TInt index(iContainer->ListBoxCurrentItemIndex());
TUint32 fileType(iEngine.FileTypeL(index));
if (!(fileType & CFileManagerItemProperties::EFolder))
{
aMenuPane.SetItemDimmed(EFileManagerMoveToFolder, 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
{
FileManagerDlgUtils::ShowErrorNoteL( resWrong );
}
}
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/1024 ) );
iProgressInfo->SetAndDraw( static_cast<TInt>( aInitialValue/1024 ) );
}
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 ),
ETrue );
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;
iProgressCurrentValue = iProgressInfo->CurrentValue();
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::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::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