diff -r 000000000000 -r d6fe6244b863 filebrowser/src/FBFileUtils.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/filebrowser/src/FBFileUtils.cpp Tue Feb 02 00:17:27 2010 +0200 @@ -0,0 +1,5147 @@ +/* +* Copyright (c) 2009 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: +* +*/ + + +// INCLUDE FILES +#include "FBFileUtils.h" +#include "FBFileOps.h" +#include "FBModel.h" +#include "FBFileDlgs.h" +#include "FBFileEditor.h" +#include "FBFileListContainer.h" +#include "FB.hrh" +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#if (!defined __SERIES60_30__ && !defined __SERIES60_31__) +#include +#endif // !defined __SERIES60_30__ && !defined __SERIES60_31__ + +#ifndef __SERIES60_30__ + #include +#endif + +_LIT(KGZipExt, ".gz"); +_LIT8(KFileNewLine, "\r\n"); +const TInt KForcedFormatTimeout = 1000000; + +// copied from coreapplicationuisdomainpskeys.h +const TUid KPSUidCoreApplicationUIs = { 0x101F8767 }; +const TUint32 KCoreAppUIsMmcRemovedWithoutEject = 0x00000109; +enum TCoreAppUIsMmcRemovedWithoutEject + { + ECoreAppUIsEjectCommandUsedUninitialized = 0, + ECoreAppUIsEjectCommandNotUsed, + ECoreAppUIsEjectCommandUsed, + ECoreAppUIsEjectCommandUsedToDrive // Low 16-bits contain this value and high 16-bits TDriveNumber to eject + }; +const TInt KDriveLetterStringLength = 3; // e.g. C:\ + +// ================= MEMBER FUNCTIONS ======================= + +CFileBrowserFileUtils* CFileBrowserFileUtils::NewL(CFileBrowserModel* aModel) + { + CFileBrowserFileUtils* self = new(ELeave) CFileBrowserFileUtils(aModel); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +// -------------------------------------------------------------------------------------------- + +CFileBrowserFileUtils::CFileBrowserFileUtils(CFileBrowserModel* aModel) : CActive(EPriorityStandard), iModel(aModel) + { + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::ConstructL() + { + User::LeaveIfError(iTimer.CreateLocal()); + User::LeaveIfError(iFs.Connect()); + User::LeaveIfError(iTz.Connect()); + + iState = EIdle; + iListingMode = ENormalEntries; + + iSortMode = EFileBrowserCmdViewSortByName; + iOrderMode = EFileBrowserCmdViewOrderAscending; + iCurrentPath = KNullDesC; + + iFileOps = CFileBrowserFileOps::NewL(iModel); + + iDriveEntryList = new(ELeave) CDriveEntryList(8); + iFileEntryList = new(ELeave) CFileEntryList(64); + iFindFileEntryList = new(ELeave) CFileEntryList(64); + iAppIconList = new(ELeave) CAppIconList(16); + iClipBoardList = new(ELeave) CFileEntryList(64); + + iDocHandler = CDocumentHandler::NewL(); + iDocHandler->SetExitObserver(this); + + // set defaults to the search settings + iSearchAttributes.iSearchDir = KNullDesC; + iSearchAttributes.iWildCards = _L("*.jpg"); + iSearchAttributes.iTextInFile = KNullDesC; + iSearchAttributes.iMinSize = 0; + iSearchAttributes.iMaxSize = 999999999; + iSearchAttributes.iMinDate = TDateTime(1980, EJanuary, 0,0,0,0,0); + iSearchAttributes.iMaxDate = TDateTime(2060, EDecember, 30,0,0,0,0); + iSearchAttributes.iRecurse = ETrue; + + // init the command array + iCommandArray = new(ELeave) CCommandArray(64); + + // get current path from settings + if (iModel->Settings().iRememberLastPath) + { + TFileName settingPath = iModel->Settings().iLastPath; + if (BaflUtils::PathExists(iFs, settingPath)) + iCurrentPath = settingPath; + + if (iCurrentPath != KNullDesC) + GetDriveListL(); + } + + CActiveScheduler::Add(this); + } + +// -------------------------------------------------------------------------------------------- + +CFileBrowserFileUtils::~CFileBrowserFileUtils() + { + Cancel(); + + // save current path from settings + if (iModel->Settings().iRememberLastPath) + { + iModel->Settings().iLastPath = iCurrentPath; + TRAP_IGNORE(iModel->SaveSettingsL(EFalse)); + } + + if (iWaitDialog) + TRAP_IGNORE(iWaitDialog->ProcessFinishedL()); + + if (iProgressDialog) + TRAP_IGNORE(iProgressDialog->ProcessFinishedL()); + + delete iFileOps; + + delete iDocHandler; + + if (iOpenFileService) + delete iOpenFileService; + + delete iClipBoardList; + delete iAppIconList; + delete iFindFileEntryList; + delete iFileEntryList; + delete iDriveEntryList; + + delete iFileMan; + + if (iCommandArray) + { + ResetCommandArray(); + delete iCommandArray; + } + + iTz.Close(); + iFs.Close(); + iTimer.Close(); + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::DoCancel() + { + iTimer.Cancel(); + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::StartExecutingCommandsL(const TDesC& aLabel) + { + if (iCommandArray->Count() >= 2) + { + // init progress bar + iProgressDialog = new(ELeave) CAknProgressDialog((reinterpret_cast(&iProgressDialog)), ETrue); + iProgressDialog->SetCallback(this); + iProgressDialog->PrepareLC(R_GENERAL_PROGRESS_NOTE); + iProgressDialog->SetCurrentLabelL( EAknCtNote, aLabel ); + iProgressInfo = iProgressDialog->GetProgressInfoL(); + iProgressInfo->SetFinalValue( CommandArrayCount() ); + iProgressDialog->RunLD(); + iProgressDialog->MakeVisible( ETrue ); + } + else if (iCommandArray->Count() >= 1) + { + // init wait dialog + iWaitDialog = new(ELeave) CAknWaitDialog((reinterpret_cast(&iWaitDialog)), ETrue); + iWaitDialog->SetCallback(this); + iWaitDialog->PrepareLC(R_GENERAL_WAIT_NOTE); + iWaitDialog->SetTextL( aLabel ); + iWaitDialog->RunLD(); + } + else + { + // no commands, just do nothing + return; + } + + + // start with the first operation + iCurrentEntry = 0; + iSucceededOperations = 0; + iFailedOperations = 0; + + // starts executing commands + ExecuteCommand(); + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::ExecuteCommand() + { + // make sure the engine isn't active, should never happen + __ASSERT_ALWAYS(!IsActive(), User::Panic(_L("FileUtils:IsActive"), 333)); + + // execute a command after a very short delay (25ms) + iTimer.After(iStatus, 25); + SetActive(); + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::RunL() + { + TInt err(KErrNone); + TInt currentCommand = iCommandArray->At(iCurrentEntry).iCommandId; + + // execute a command from the queue + switch(currentCommand) + { + case EFileBrowserFileOpCommandAttribs: + { + CCommandParamsAttribs* params = static_cast(iCommandArray->At(iCurrentEntry).iParameters); + err = iFileOps->Attribs(params->iSourceEntry, params->iSetMask, params->iClearMask, params->iTime, params->iSwitch); + } + break; + + case EFileBrowserFileOpCommandCopy: + { + CCommandParamsCopyOrMove* params = static_cast(iCommandArray->At(iCurrentEntry).iParameters); + err = iFileOps->Copy(params->iSourceEntry, params->iTargetPath, params->iSwitch); + } + break; + + case EFileBrowserFileOpCommandMove: + { + CCommandParamsCopyOrMove* params = static_cast(iCommandArray->At(iCurrentEntry).iParameters); + err = iFileOps->Copy(params->iSourceEntry, params->iTargetPath, params->iSwitch, ETrue); + } + break; + + case EFileBrowserFileOpCommandRename: + { + CCommandParamsRename* params = static_cast(iCommandArray->At(iCurrentEntry).iParameters); + err = iFileOps->Rename(params->iSourceEntry, params->iTargetPath, params->iSwitch); + } + break; + + case EFileBrowserFileOpCommandDelete: + { + CCommandParamsDelete* params = static_cast(iCommandArray->At(iCurrentEntry).iParameters); + err = iFileOps->Delete(params->iSourceEntry, params->iSwitch); + } + break; + + case EFileBrowserFileOpCommandDriveSnapShot: + { + CCommandParamsDriveSnapShot* params = static_cast(iCommandArray->At(iCurrentEntry).iParameters); + err = iFileOps->DriveSnapShot(params->iSourceDriveLetter, params->iTargetDriveLetter); + } + break; + + default: + User::Panic (_L("Unknown command"), 400); + break; + } + + + if (err == KErrNone) + { + iSucceededOperations++; + } + else if ( err != KErrCancel ) + { + iFailedOperations++; + } + + iLastError = err; + + // check for more commands in queue + TRAP_IGNORE( CheckForMoreCommandsL() ); + } + +// --------------------------------------------------------------------------- + +TInt CFileBrowserFileUtils::RunError(TInt aError) + { + _LIT(KMessage, "Command error %d"); + TBuf<128> noteMsg; + noteMsg.Format(KMessage, aError); + + iModel->EikonEnv()->InfoMsg(noteMsg); + + TRAP_IGNORE( CheckForMoreCommandsL() ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- + +void CFileBrowserFileUtils::CheckForMoreCommandsL() + { + //LOGSTRING("Creator: CCreatorEngine::CheckForMoreCommandsL"); + + // update the progress bar + if (iProgressInfo) + iProgressInfo->IncrementAndDraw(1); + + // check if we have more commands to be executed + if (iCurrentEntry >= CommandArrayCount() - 1) + { + //LOGSTRING("Creator: CCreatorEngine::CheckForMoreCommandsL all done"); + + // all done, free resources + ResetCommandArray(); + + // deactive secure backup if it was activated by a file command + iFileOps->DeActivateSecureBackUpViaFileOp(); + + // dismiss any wait/progress dialogs + if (iWaitDialog) + { + TRAP_IGNORE(iWaitDialog->ProcessFinishedL()); + iWaitDialog = NULL; + } + if (iProgressDialog) + { + TRAP_IGNORE(iProgressDialog->ProcessFinishedL()); + iProgressDialog = NULL; + } + + + // show result note + if ( iSucceededOperations == 0 && iFailedOperations == 0 ) + { + // single operation cancelled -> show nothing + } + else if (iSucceededOperations == 1 && iFailedOperations == 0) + { + _LIT(KMessage, "Operation succeeded"); + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(KMessage); + } + else if (iSucceededOperations > 0 && iFailedOperations == 0) + { + _LIT(KMessage, "%d operations succeeded"); + TBuf<128> noteMsg; + noteMsg.Format(KMessage, iSucceededOperations); + + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(noteMsg); + } + else if (iSucceededOperations == 0 && iFailedOperations > 1) + { + _LIT(KMessage, "%d operations failed"); + TBuf<128> noteMsg; + noteMsg.Format(KMessage, iFailedOperations); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(noteMsg); + } + else if (iSucceededOperations > 0 && iFailedOperations > 0) + { + _LIT(KMessage, "%d operations succeeded, %d failed"); + TBuf<128> noteMsg; + noteMsg.Format(KMessage, iSucceededOperations, iFailedOperations); + + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(noteMsg); + } + else + { + CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv()); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD( textResolver->ResolveErrorString(iLastError, CTextResolver::ECtxNoCtxNoSeparator) ); + + CleanupStack::PopAndDestroy(); //textResolver + } + + RefreshViewL(); + + } + else + { + // maintain requests + iCurrentEntry++; + + //LOGSTRING2("Creator: CCreatorEngine::CheckForMoreCommandsL iCurrentEntry=%d", iCurrentEntry); + + ExecuteCommand(); + } + } +// -------------------------------------------------------------------------------------------- + +// This callback function is called when cancel button of the progress bar was pressed +void CFileBrowserFileUtils::DialogDismissedL(TInt aButtonId) + { + iProgressDialog = NULL; + iProgressInfo = NULL; + iWaitDialog = NULL; + + // check if cancel button was pressed + if (aButtonId == EAknSoftkeyCancel) + { + // cancel the active object, command executer + Cancel(); + + iFileOps->CancelOp(); + + ResetCommandArray(); + + CAknInformationNote* note = new (ELeave) CAknInformationNote; + note->ExecuteLD(_L("Cancelled")); + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::AppendToCommandArrayL(TInt aCommand, CCommandParamsBase* aParameters) + { + if (iCommandArray) + iCommandArray->AppendL( TCommand(aCommand, aParameters) ); + else + User::Leave(KErrNotReady); + } + +// -------------------------------------------------------------------------------------------- + +TInt CFileBrowserFileUtils::CommandArrayCount() const + { + TInt count(0); + + if (iCommandArray) + count = iCommandArray->Count(); + + return count; + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::ResetCommandArray() + { + // delete params first + for (TInt i=0; iAt(i).iParameters ) + { + delete iCommandArray->At(i).iParameters; + iCommandArray->At(i).iParameters = NULL; + } + } + + // reset the entries + iCommandArray->Reset(); + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::HandleSettingsChangeL() + { + if (iModel->FileListContainer()) + { + iModel->FileListContainer()->SetScreenLayoutL(iModel->Settings().iDisplayMode); + iModel->FileListContainer()->CreateListBoxL(iModel->Settings().iFileViewMode); + //iModel->FileListContainer()->SetNaviPaneTextL(iCurrentPath); + RefreshViewL(); + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::SetSortModeL(TInt aSortMode) + { + iSortMode = aSortMode; + RefreshViewL(); + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::SetOrderModeL(TInt aOrderMode) + { + iOrderMode = aOrderMode; + RefreshViewL(); + } + +// -------------------------------------------------------------------------------------------- + +TKeyResponse CFileBrowserFileUtils::HandleOfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType) + { + if(aType != EEventKey) + return EKeyWasNotConsumed; + + TBool shiftKeyPressed = (aKeyEvent.iModifiers & EModifierShift) || + (aKeyEvent.iModifiers & EModifierLeftShift) || + (aKeyEvent.iModifiers & EModifierRightShift); + TBool controlKeyPressed = (aKeyEvent.iModifiers & EModifierCtrl) || + (aKeyEvent.iModifiers & EModifierRightCtrl); + + // handle left arrow key press + if (aKeyEvent.iCode == EKeyLeftArrow) + { + MoveUpOneLevelL(); + return EKeyWasConsumed; + } + + // handle right arrow key press + else if (aKeyEvent.iCode == EKeyRightArrow) + { + if (IsDriveListViewActive() && iDriveEntryList->Count() > 0) + { + MoveDownToDirectoryL(); + return EKeyWasConsumed; + } + else if (iFileEntryList->Count() > 0) + { + MoveDownToDirectoryL(); + return EKeyWasConsumed; + } + } + + // skip OK/Enter keys when shift or ctrl is pressed because those are needed by the listbox + else if ((aKeyEvent.iCode == EKeyOK || aKeyEvent.iCode == EKeyEnter) && (shiftKeyPressed || controlKeyPressed)) + { + return EKeyWasNotConsumed; + } + + // handle OK/Enter keys + else if (aKeyEvent.iCode == EKeyOK || aKeyEvent.iCode == EKeyEnter) + { + if (IsDriveListViewActive() && iDriveEntryList->Count() > 0) + { + MoveDownToDirectoryL(); + return EKeyWasConsumed; + } + else if (iFileEntryList->Count() > 0) + { + TFileEntry fileEntry = iFileEntryList->At(iModel->FileListContainer()->CurrentListBoxItemIndex()); + + if (fileEntry.iEntry.IsDir()) + MoveDownToDirectoryL(); + else + OpenCommonFileActionQueryL(); + + return EKeyWasConsumed; + } + } + + // handle Delete/Backspace keys + else if (!iModel->FileListContainer()->SearchField() && (aKeyEvent.iCode == EKeyBackspace || aKeyEvent.iCode == EKeyDelete) && + !iModel->FileUtils()->IsCurrentDriveReadOnly() && !iModel->FileUtils()->IsDriveListViewActive()) + { + DeleteL(); + return EKeyWasConsumed; + } + + return EKeyWasNotConsumed; + } +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::RefreshViewL() + { + if (iModel->FileListContainer()) + { + // update navi pane text + if (iListingMode == ENormalEntries) + iModel->FileListContainer()->SetNaviPaneTextL(iCurrentPath); + else if (iListingMode == ESearchResults) + iModel->FileListContainer()->SetNaviPaneTextL(_L("Search results")); + else if (iListingMode == EOpenFiles) + iModel->FileListContainer()->SetNaviPaneTextL(_L("Open files")); + else if (iListingMode == EMsgAttachmentsInbox) + iModel->FileListContainer()->SetNaviPaneTextL(_L("Attachments in Inbox")); + else if (iListingMode == EMsgAttachmentsDrafts) + iModel->FileListContainer()->SetNaviPaneTextL(_L("Attachments in Drafts")); + else if (iListingMode == EMsgAttachmentsSentItems) + iModel->FileListContainer()->SetNaviPaneTextL(_L("Attachments in Sent Items")); + else if (iListingMode == EMsgAttachmentsOutbox) + iModel->FileListContainer()->SetNaviPaneTextL(_L("Attachments in Outbox")); + + // create a list box if it doesn't already exist + if (!iModel->FileListContainer()->ListBox()) + iModel->FileListContainer()->CreateListBoxL(iModel->Settings().iFileViewMode); + + // clear selections if any + iModel->FileListContainer()->ListBox()->ClearSelection(); + + // make sure that the search field is disabled + iModel->FileListContainer()->DisableSearchFieldL(); + + // read directory listing + GenerateDirectoryDataL(); + + // set an icon array + iModel->FileListContainer()->SetListBoxIconArrayL(GenerateIconArrayL()); + + // set text items + iModel->FileListContainer()->SetListBoxTextArrayL(GenerateItemTextArrayL()); + + // make sure that the current item index is not out of array + if (iModel->FileListContainer()->CurrentListBoxItemIndex() == -1 && // -1 is a hardcoded value meaning that no current item index + iModel->FileListContainer()->ListBox()->Model()->NumberOfItems() > 0) + iModel->FileListContainer()->ListBox()->SetCurrentItemIndex( iModel->FileListContainer()->ListBox()->Model()->NumberOfItems() - 1 ); + + } + + iModel->FileListContainer()->UpdateToolbar(); + } + +// -------------------------------------------------------------------------------------------- + +CAknIconArray* CFileBrowserFileUtils::GenerateIconArrayL(TBool aGenerateNewBasicIconArray) + { + CAknIconArray* iconArray = NULL; + + if (aGenerateNewBasicIconArray) + { + iconArray = new(ELeave) CAknIconArray(16); + } + else + { + if (iModel->FileListContainer()) + iconArray = iModel->FileListContainer()->ListBoxIconArrayL(); + + if (!iconArray) + iconArray = new(ELeave) CAknIconArray(16); + } + + + CleanupStack::PushL(iconArray); + + // generate basic items if not already existing + if (iconArray->Count() < EFixedIconListLength) + { + // reset arrays + iconArray->Reset(); + iAppIconList->Reset(); + + // get default control color + TRgb defaultColor; + defaultColor = iModel->EikonEnv()->Color(EColorControlText); + + // create a color icon of the marking indicator + CFbsBitmap* markBitmap = NULL; + CFbsBitmap* markBitmapMask = NULL; + + AknsUtils::CreateColorIconL(AknsUtils::SkinInstance(), + KAknsIIDQgnIndiMarkedAdd, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG13, + markBitmap, + markBitmapMask, + AknIconUtils::AvkonIconFileName(), + EMbmAvkonQgn_indi_marked_add, + EMbmAvkonQgn_indi_marked_add_mask, + defaultColor + ); + + // 0 marking indicator + CGulIcon* markIcon = CGulIcon::NewL(markBitmap, markBitmapMask); + iconArray->AppendL(markIcon); + + // 1 empty + AppendGulIconToIconArrayL(iconArray, AknIconUtils::AvkonIconFileName(), + EMbmAvkonQgn_prop_empty, EMbmAvkonQgn_prop_empty_mask, KAknsIIDQgnPropEmpty); + // 2 phone memory + AppendGulIconToIconArrayL(iconArray, AknIconUtils::AvkonIconFileName(), + EMbmAvkonQgn_prop_phone_memc, EMbmAvkonQgn_prop_phone_memc_mask, KAknsIIDQgnPropPhoneMemc); + // 3 memory card + AppendGulIconToIconArrayL(iconArray, KMemoryCardUiBitmapFile, + EMbmAknmemorycarduiQgn_prop_mmc_memc, EMbmAknmemorycarduiQgn_prop_mmc_memc_mask, KAknsIIDQgnPropMmcMemc); + // 4 memory card disabled + AppendGulIconToIconArrayL(iconArray, KMemoryCardUiBitmapFile, + EMbmAknmemorycarduiQgn_prop_mmc_non, EMbmAknmemorycarduiQgn_prop_mmc_non_mask, KAknsIIDQgnPropMmcNon); + // 5 folder + AppendGulIconToIconArrayL(iconArray, AknIconUtils::AvkonIconFileName(), + EMbmAvkonQgn_prop_folder_small, EMbmAvkonQgn_prop_folder_small_mask, KAknsIIDQgnPropFolderSmall); + // 6 folder with subfolders + AppendGulIconToIconArrayL(iconArray, AknIconUtils::AvkonIconFileName(), + EMbmAvkonQgn_prop_folder_sub_small, EMbmAvkonQgn_prop_folder_sub_small_mask, KAknsIIDQgnPropFolderSubSmall); + // 7 current folder + AppendGulIconToIconArrayL(iconArray, AknIconUtils::AvkonIconFileName(), + EMbmAvkonQgn_prop_folder_current, EMbmAvkonQgn_prop_folder_current_mask, KAknsIIDQgnPropFolderCurrent); + } + + // append custom icons if not in drive list view and setting is enabled + if (!aGenerateNewBasicIconArray && !IsDriveListViewActive() && iModel->Settings().iShowAssociatedIcons) + { + // init id counter + TInt idCounter(EFixedIconListLength + iAppIconList->Count()); + + // loop all items in the file list + for (TInt i=0; iCount(); i++) + { + TFileEntry& fileEntry = iFileEntryList->At(i); + + // just check for normal files + if (!fileEntry.iEntry.IsDir()) + { + TUid appUid = GetAppUid(fileEntry); + TInt iconId = AppIconIdForUid(appUid); + + if (appUid != KNullUid && iconId == KErrNotFound) + { + // icon not found from the icon array, generate it + CFbsBitmap* bitmap = NULL; + CFbsBitmap* mask = NULL; + CGulIcon* appIcon = NULL; + + TRAPD(err, + AknsUtils::CreateAppIconLC(AknsUtils::SkinInstance(), appUid, EAknsAppIconTypeList, bitmap, mask); + appIcon = CGulIcon::NewL(bitmap, mask); + CleanupStack::Pop(2); //bitmap, mask + ); + + if (err == KErrNone) + { + TAppIcon appIconEntry; + appIconEntry.iId = idCounter; + appIconEntry.iUid = appUid; + + appIcon->SetBitmapsOwnedExternally(EFalse); + iconArray->AppendL(appIcon); + iAppIconList->AppendL(appIconEntry); + + fileEntry.iIconId = idCounter; + + idCounter++; + } + else + { + delete bitmap; + delete mask; + + TAppIcon appIconEntry; + appIconEntry.iId = EFixedIconEmpty; + appIconEntry.iUid = appUid; + + iAppIconList->AppendL(appIconEntry); + } + } + + else if (appUid != KNullUid && iconId >= 0) + { + // we already have already generated an icon for this uid, use it + fileEntry.iIconId = iconId; + } + } + } + } + + CleanupStack::Pop(); //iconArray + return iconArray; + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::AppendGulIconToIconArrayL(CAknIconArray* aIconArray, const TDesC& aIconFile, TInt aIconId, TInt aMaskId, const TAknsItemID aAknsItemId) + { + CGulIcon* icon = AknsUtils::CreateGulIconL( + AknsUtils::SkinInstance(), + aAknsItemId, + aIconFile, + aIconId, + aMaskId); + CleanupStack::PushL(icon); + + icon->SetBitmapsOwnedExternally(EFalse); + aIconArray->AppendL(icon); + + CleanupStack::Pop(); //icon + } + +// -------------------------------------------------------------------------------------------- + +TInt CFileBrowserFileUtils::AppIconIdForUid(TUid aUid) + { + TInt result(KErrNotFound); + + for (TInt i=0; iCount(); i++) + { + if (iAppIconList->At(i).iUid == aUid) + { + result = iAppIconList->At(i).iId; + break; + } + } + + return result; + } + +// -------------------------------------------------------------------------------------------- + +TUid CFileBrowserFileUtils::GetAppUid(TFileEntry aFileEntry) + { + TFileName fullPath; + fullPath.Copy(aFileEntry.iPath); + fullPath.Append(aFileEntry.iEntry.iName); + + TParse parsedName; + parsedName.Set(fullPath, NULL, NULL); + + // this will boost performance in \sys\bin folder + if (parsedName.Ext().CompareF(_L(".dll")) == 0 || parsedName.Ext().CompareF(_L(".rsc")) == 0) + return KNullUid; + + TInt err1(KErrNone), err2(KErrNone); + TUid appUid; + TDataType dataType; + TBool isProgram; + + err1 = iModel->LsSession().AppForDocument(fullPath, appUid, dataType); + err2 = iModel->LsSession().IsProgram(fullPath, isProgram); + + if (err1 == KErrNone && err2 == KErrNone) + { + if (isProgram) + { + // get the real app Uid from the app list + TApaAppInfo appInfo; + iModel->LsSession().GetAllApps(); + + while (iModel->LsSession().GetNextApp(appInfo) == KErrNone) + { + if (fullPath.CompareF(appInfo.iFullName) == 0) + return appInfo.iUid; + } + } + else + { + // return the app Uid associated for it + return appUid; + } + } + + return KNullUid; + } +// -------------------------------------------------------------------------------------------- + +CDesCArray* CFileBrowserFileUtils::GenerateItemTextArrayL() + { + CDesCArray* textArray = new(ELeave) CDesCArrayFlat(64); + CleanupStack::PushL(textArray); + + if (IsDriveListViewActive()) + { + _LIT(KSimpleDriveEntry, "%d\t%c: <%S>\t\t"); + _LIT(KExtendedDriveEntry, "%d\t%c: <%S>\t%LD / %LD kB\t"); + + for (TInt i=0; iCount(); i++) + { + TFileName textEntry; + TDriveEntry driveEntry = iDriveEntryList->At(i); + + if (iModel->Settings().iFileViewMode == EFileViewModeSimple) + { + textEntry.Format(KSimpleDriveEntry, driveEntry.iIconId, TUint(driveEntry.iLetter), &driveEntry.iMediaTypeDesc); + } + else if (iModel->Settings().iFileViewMode == EFileViewModeExtended) + { + textEntry.Format(KExtendedDriveEntry, driveEntry.iIconId, TUint(driveEntry.iLetter), &driveEntry.iMediaTypeDesc, driveEntry.iVolumeInfo.iFree/1024, driveEntry.iVolumeInfo.iSize/1024); + } + + textArray->AppendL(textEntry); + } + } + + else + { + _LIT(KSimpleFileEntry, "%d\t%S\t\t"); + _LIT(KExtendedFileEntry, "%d\t%S\t%S\t"); + + for (TInt i=0; iCount(); i++) + { + TBuf textEntry; + TFileEntry fileEntry = iFileEntryList->At(i); + + // format text line entries + if (iModel->Settings().iFileViewMode == EFileViewModeSimple) + { + textEntry.Format(KSimpleFileEntry, fileEntry.iIconId, &fileEntry.iEntry.iName); + } + else if (iModel->Settings().iFileViewMode == EFileViewModeExtended) + { + TBuf<128> extraData; + + // append entry date + TTime entryModified = fileEntry.iEntry.iModified; + if ( iTz.ConvertToLocalTime( entryModified ) == KErrNone ) + { + entryModified = fileEntry.iEntry.iModified; + } + + _LIT(KCurrentDate,"%D%M%*Y%/0%1%/1%2%/2%3%/3 %-B%:0%J%:1%T%:2%S%:3%+B"); + entryModified.FormatL(extraData, KCurrentDate); + + // for a directory append number of entries and for a file the file size + if (fileEntry.iEntry.IsDir() && fileEntry.iDirEntries >= 0) + { + extraData.Append(_L(" - ")); + extraData.AppendNum(fileEntry.iDirEntries); + + if (fileEntry.iDirEntries == 1) + extraData.Append(_L(" entry")); + else + extraData.Append(_L(" entries")); + } + + // normal file entry + else if (!fileEntry.iEntry.IsDir()) + { + extraData.Append(_L(" - ")); + + if (fileEntry.iEntry.iSize < 1024) + { + extraData.AppendNum(fileEntry.iEntry.iSize); + extraData.Append(_L(" B")); + } + else if (fileEntry.iEntry.iSize < 1024*1024) + { + TReal sizeKB = (TReal)fileEntry.iEntry.iSize / 1024; + extraData.AppendNum(sizeKB, TRealFormat(KDefaultRealWidth, 1)); + extraData.Append(_L(" kB")); + } + else + { + TReal sizeMB = (TReal)fileEntry.iEntry.iSize / (1024*1024); + extraData.AppendNum(sizeMB, TRealFormat(KDefaultRealWidth, 1)); + extraData.Append(_L(" MB")); + } + } + + // append attribute flags if any + TBuf<4> atts; + if (fileEntry.iEntry.IsArchive()) + atts.Append(_L("A")); + if (fileEntry.iEntry.IsHidden()) + atts.Append(_L("H")); + if (fileEntry.iEntry.IsReadOnly()) + atts.Append(_L("R")); + if (fileEntry.iEntry.IsSystem()) + atts.Append(_L("S")); + + if (atts.Length() > 0) + { + extraData.Append(_L(" - [")); + extraData.Append(atts); + extraData.Append(_L("]")); + } + + // format + textEntry.Format(KExtendedFileEntry, fileEntry.iIconId, &fileEntry.iEntry.iName, &extraData); + } + + if( fileEntry.iEntry.iName.Length() + fileEntry.iPath.Length() <= KMaxFileName ) + { + textArray->AppendL(textEntry); + } + else + { + // Too long filenames are deleted from the list + iFileEntryList->Delete(i--); + } + } + } + + CleanupStack::Pop(); //textArray + return textArray; + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::GenerateDirectoryDataL() + { + if (iListingMode == ENormalEntries) + { + if (IsDriveListViewActive()) + GetDriveListL(); + else + GetDirectoryListingL(); + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::GetDriveListL() + { + TDriveList driveList; + + // get drive listing depending of the support for network drives + if (iModel->Settings().iSupportNetworkDrives) + { + #ifndef __SERIES60_30__ + #ifndef __SERIES60_31__ + User::LeaveIfError(iFs.DriveList(driveList, KDriveAttAll)); + #endif + #else + User::LeaveIfError(iFs.DriveList(driveList)); + #endif + } + else + { + User::LeaveIfError(iFs.DriveList(driveList)); + } + + iDriveEntryList->Reset(); + + for (TInt i=0; iCount(); + } + + iDriveEntryList->AppendL(driveEntry); + } + } + + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::GetDirectoryListingL() + { + iFileEntryList->Reset(); + + TInt sortMode(ESortByName); + if (iSortMode == EFileBrowserCmdViewSortByExtension) + sortMode = ESortByExt; + else if (iSortMode == EFileBrowserCmdViewSortBySize) + sortMode = ESortBySize; + else if (iSortMode == EFileBrowserCmdViewSortByDate) + sortMode = ESortByDate; + + TInt orderMode(EAscending); + if (iOrderMode == EFileBrowserCmdViewOrderDescending) + orderMode = EDescending; + + CDir* dir = NULL; + if (iFs.GetDir(iCurrentPath, KEntryAttMatchMask, sortMode | orderMode | EDirsFirst, dir) == KErrNone) + { + CleanupStack::PushL(dir); + + for (TInt i=0; iCount(); i++) + { + TFileEntry fileEntry; + fileEntry.iPath = iCurrentPath; + fileEntry.iEntry = (*dir)[i]; + fileEntry.iDirEntries = KErrNotFound; + fileEntry.iIconId = EFixedIconEmpty; + + if ( iPrevFolderName != KNullDesC && iPrevFolderName == fileEntry.iEntry.iName ) + { + iPrevFolderIndex = i; + } + + // check for directory entries + if (fileEntry.iEntry.IsDir()) + { + fileEntry.iIconId = EFixedIconFolder; + + TFileName subPath = fileEntry.iPath; + subPath.Append(fileEntry.iEntry.iName); + subPath.Append(_L("\\")); + + // get number of entries in this directory if extended info about sub directories enabled + if (iModel->Settings().iShowSubDirectoryInfo && iModel->Settings().iFileViewMode == EFileViewModeExtended) + { + CDir* subDir = NULL; + if (iFs.GetDir(subPath, KEntryAttMatchMask, ESortNone | EDirsFirst, subDir) == KErrNone) + { + fileEntry.iDirEntries = subDir->Count(); + delete subDir; + } + } + + // apply subfolder icon for known directories (speed improvement) + if (subPath[0]=='Z' && (subPath.CompareF(_L("Z:\\data\\"))==0 || subPath.CompareF(_L("Z:\\Nokia\\"))==0 + || subPath.Compare(_L("Z:\\private\\"))==0 || subPath.Compare(_L("Z:\\resource\\"))==0 + || subPath.Compare(_L("Z:\\sys\\"))==0 || subPath.Compare(_L("Z:\\system\\"))==0)) + { + fileEntry.iIconId = EFixedIconFolderSub; + } + else if (subPath[0]=='Z' && (subPath.CompareF(_L("Z:\\sys\\bin\\"))==0)) + { + // normal folder icon for these ones + fileEntry.iIconId = EFixedIconFolder; + } + else + { + // check if this folder has subdirectories + CDir* subDir = NULL; + if (iFs.GetDir(subPath, KEntryAttDir|KEntryAttMatchMask, ESortNone | EDirsFirst, subDir) == KErrNone) + { + for (TInt j=0; jCount(); j++) + { + TEntry entry = (*subDir)[j]; + + if (entry.IsDir()) + { + fileEntry.iIconId = EFixedIconFolderSub; + break; + } + } + + delete subDir; + } + } + } + + iFileEntryList->AppendL(fileEntry); + } + + CleanupStack::PopAndDestroy(); //dir + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::MoveUpOneLevelL() + { + iPrevFolderIndex = KErrNotFound; + iPrevFolderName.Zero(); + + // change back to normal mode or move up + if (iListingMode != ENormalEntries) + { + iListingMode = ENormalEntries; + } + else + { + // do nothing if displaying drive list view + if (IsDriveListViewActive()) + return; + + if (iCurrentPath.Length() <= KDriveLetterStringLength) + { + if ( iCurrentPath.Length() > 0 ) + { + iPrevFolderName.Append( iCurrentPath[0] ); + } + // move to drive list view if the current path is already short enough + iCurrentPath = KNullDesC; + } + else + { + // move one directory up + TInt marker(iCurrentPath.Length()); + + // find second last dir marker + for (TInt i=iCurrentPath.Length()-2; i>=0; i--) + { + if (iCurrentPath[i] == '\\') + { + marker = i; + break; + } + + } + + // update iPrevDir with the directory name that we just left + iPrevFolderName.Copy( iCurrentPath.RightTPtr( iCurrentPath.Length() - marker - 1 ) ); + iPrevFolderName.Delete( iPrevFolderName.Length() -1, 2 ); // remove extra '\\' + + iCurrentPath = iCurrentPath.LeftTPtr(marker+1); + } + } + + if (iModel->FileListContainer()) + { + //iModel->FileListContainer()->DisableSearchFieldL(); + //iModel->FileListContainer()->ListBox()->ClearSelection(); + iModel->FileListContainer()->ListBox()->SetCurrentItemIndex(0); + //iModel->FileListContainer()->SetNaviPaneTextL(iCurrentPath); + } + + // update view + RefreshViewL(); + + if ( iModel->Settings().iRememberFolderSelection && + iModel->FileListContainer() && iPrevFolderIndex > KErrNotFound ) + { + + TInt visibleItems = iModel->FileListContainer()->ListBox()->Rect().Height() / + iModel->FileListContainer()->ListBox()->ItemHeight() + - 1; // for the title row + + // By default, the selected item would be the last visible item on the listbox. + // We want the selected item be displayed at the middle of the listbox, so we + // select one of the successor items first to scroll down a bit + iModel->FileListContainer()->ListBox()->SetCurrentItemIndex( + Min( iModel->FileListContainer()->ListBox()->Model()->ItemTextArray()->MdcaCount() -1, + iPrevFolderIndex + visibleItems / 2 ) ); + + // ...and after that we select the the correct item. + iModel->FileListContainer()->ListBox()->SetCurrentItemIndex( iPrevFolderIndex ); + + // update view + RefreshViewL(); + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::MoveDownToDirectoryL() + { + // change back to normal mode + if (iListingMode != ENormalEntries) + { + iListingMode = ENormalEntries; + } + + TInt index = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (index >= 0) + { + TBool needsRefresh(EFalse); + + if (IsDriveListViewActive()) + { + // currently in a drive list view, move to root of selected drive + if (iDriveEntryList->Count() > index) + { + TDriveEntry driveEntry = iDriveEntryList->At(index); + + iCurrentPath.Append(driveEntry.iLetter); + iCurrentPath.Append(_L(":\\")); + + needsRefresh = ETrue; + } + } + else + { + // otherwise just append the new directory + if (iFileEntryList->Count() > index) + { + TFileEntry fileEntry = iFileEntryList->At(index); + + if (fileEntry.iEntry.IsDir()) + { + iCurrentPath.Copy(fileEntry.iPath); + iCurrentPath.Append(fileEntry.iEntry.iName); + iCurrentPath.Append(_L("\\")); + + needsRefresh = ETrue; + } + } + } + + if (needsRefresh && iModel->FileListContainer()) + { + //iModel->FileListContainer()->DisableSearchFieldL(); + //iModel->FileListContainer()->ListBox()->ClearSelection(); + iModel->FileListContainer()->ListBox()->SetCurrentItemIndex(0); + //iModel->FileListContainer()->SetNaviPaneTextL(iCurrentPath); + + // update view + RefreshViewL(); + } + } + } + +// -------------------------------------------------------------------------------------------- + +TBool CFileBrowserFileUtils::IsCurrentDriveReadOnly() + { + if (iListingMode !=ENormalEntries || iCurrentPath.Length() < 2) + return EFalse; + else + { + for (TInt i=0; iCount(); i++) + { + TDriveEntry driveEntry = iDriveEntryList->At(i); + + if (driveEntry.iLetter == iCurrentPath[0]) + { + if (driveEntry.iVolumeInfo.iDrive.iMediaAtt == KMediaAttWriteProtected || driveEntry.iVolumeInfo.iDrive.iMediaAtt == KMediaAttLocked || driveEntry.iVolumeInfo.iDrive.iDriveAtt == KDriveAbsent) + return ETrue; + else + return EFalse; + } + } + } + + return EFalse; + } + +// -------------------------------------------------------------------------------------------- + +TBool CFileBrowserFileUtils::IsCurrentItemDirectory() + { + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (currentItemIndex < 0) + return EFalse; + else + { + if (iFileEntryList->Count() > currentItemIndex) + { + TFileEntry fileEntry = iFileEntryList->At(currentItemIndex) ; + return fileEntry.iEntry.IsDir(); + } + else + return EFalse; + } + + } + +// -------------------------------------------------------------------------------------------- + +TInt CFileBrowserFileUtils::GetSelectedItemsOrCurrentItemL(CFileEntryList* aFileEntryList) + { + aFileEntryList->Reset(); + + const CArrayFix* selectionIndexes = iModel->FileListContainer()->ListBoxSelectionIndexes(); + + // by default use selected items + if (selectionIndexes && selectionIndexes->Count() > 0) + { + TInt ref(0); + TKeyArrayFix key(0, ECmpTUint16); + TInt index(0); + + for (TInt i=0; iCount(); i++) + { + ref = i; + + if (selectionIndexes->Find(ref, key, index) == 0) + { + aFileEntryList->AppendL(iFileEntryList->At(i)); + } + } + } + + // or if none selected, use the current item index + else + { + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iFileEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + aFileEntryList->AppendL(iFileEntryList->At(currentItemIndex)); + } + } + + return aFileEntryList->Count(); + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::ClipboardCutL() + { + iClipBoardMode = EClipBoardModeCut; + TInt operations = GetSelectedItemsOrCurrentItemL(iClipBoardList); + + _LIT(KMessage, "%d entries cut to clipboard"); + TFileName noteMsg; + noteMsg.Format(KMessage, operations); + + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(noteMsg); + + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::ClipboardCopyL() + { + iClipBoardMode = EClipBoardModeCopy; + TInt operations = GetSelectedItemsOrCurrentItemL(iClipBoardList); + + _LIT(KMessage, "%d entries copied to clipboard"); + TFileName noteMsg; + noteMsg.Format(KMessage, operations); + + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(noteMsg); + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::ClipboardPasteL() + { + if (iClipBoardMode == EClipBoardModeCut) + { + DoCopyToFolderL(iClipBoardList, iCurrentPath, ETrue); + iClipBoardList->Reset(); + } + else if (iClipBoardMode == EClipBoardModeCopy) + { + DoCopyToFolderL(iClipBoardList, iCurrentPath, EFalse); + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::CopyToFolderL(TBool aMove) + { + TFileName destinationFolder; + + // generate an icon array + CAknIconArray* iconArray = GenerateIconArrayL(ETrue); + CleanupStack::PushL(iconArray); + + // run folder selection dialog + CFileBrowserDestinationFolderSelectionDlg* dlg = CFileBrowserDestinationFolderSelectionDlg::NewL(destinationFolder, iDriveEntryList, iconArray); + + TBool dialogOK(EFalse); + + if (aMove) + dialogOK = dlg->RunMoveDlgLD(); + else + dialogOK = dlg->RunCopyDlgLD(); + + if (dialogOK) + { + // get entry list + CFileEntryList* entryList = new(ELeave) CFileEntryList(32); + GetSelectedItemsOrCurrentItemL(entryList); + CleanupStack::PushL(entryList); + + // do the file operations + if (aMove) + DoCopyToFolderL(entryList, destinationFolder, ETrue); + else + DoCopyToFolderL(entryList, destinationFolder, EFalse); + + CleanupStack::PopAndDestroy(); // entryList + } + + CleanupStack::Pop(); //iconArray + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::DoCopyToFolderL(CFileEntryList* aEntryList, const TDesC& aTargetDir, TBool aDeleteSource) + { + if (aEntryList && aEntryList->Count() > 0) + { + TBool someEntryExists(EFalse); + TBool doFileOperations(ETrue); + TInt queryIndex(0); + TFileName postFix; + TInt overWriteFlags = CFileMan::EOverWrite; + + // check if some destination entries also exists + for (TInt i=0; iCount(); i++) + { + TFileEntry fileEntry = aEntryList->At(i); + + TFileName targetEntry = aTargetDir; + targetEntry.Append(fileEntry.iEntry.iName); + + if (fileEntry.iEntry.IsDir()) + { + targetEntry.Append(_L("\\")); + + if (BaflUtils::PathExists(iFs, targetEntry)) + { + someEntryExists = ETrue; + break; + } + } + else + { + if (BaflUtils::FileExists(iFs, targetEntry)) + { + someEntryExists = ETrue; + break; + } + } + } + + // show a query if existing entries + if (someEntryExists) + { + CAknListQueryDialog* listQueryDlg = new(ELeave) CAknListQueryDialog(&queryIndex); + + if (listQueryDlg->ExecuteLD(R_ENTRY_OVERWRITE_TYPE_QUERY)) + { + if (queryIndex == EFileActionQueryPostFix) + { + CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL(postFix); + textQuery->SetPromptL(_L("Postfix:")); + + if (textQuery->ExecuteLD(R_GENERAL_TEXT_QUERY)) + { + + } + else + { + doFileOperations = EFalse; + } + } + else if (queryIndex == EFileActionSkipAllExisting) + { + overWriteFlags = 0; + } + } + else + { + doFileOperations = EFalse; + } + } + + + if (doFileOperations) + { + // set correct command id depending if we are copying or moving + TInt commandId(EFileBrowserFileOpCommandCopy); + if (aDeleteSource) + commandId = EFileBrowserFileOpCommandMove; + + // do the file operations for each entry + for (TInt i=0; iCount(); i++) + { + TFileEntry fileEntry = aEntryList->At(i); + + TFileName targetEntry = aTargetDir; + targetEntry.Append(fileEntry.iEntry.iName); + + if (queryIndex == EFileActionGenerateUniqueFilenames) + { + CApaApplication::GenerateFileName(iFs, targetEntry); + } + else if (queryIndex == EFileActionQueryPostFix) + { + targetEntry.Append(postFix); + } + + + // append the new command to the command array + if (fileEntry.iEntry.IsDir()) + { + AppendToCommandArrayL(commandId, + new(ELeave)CCommandParamsCopyOrMove(fileEntry, targetEntry, overWriteFlags|CFileMan::ERecurse) + ); + } + else + { + AppendToCommandArrayL(commandId, + new(ELeave)CCommandParamsCopyOrMove(fileEntry, targetEntry, overWriteFlags) + ); + } + + } + + // execute all operations + if (aDeleteSource) + StartExecutingCommandsL(_L("Moving")); + else + StartExecutingCommandsL(_L("Copying")); + } + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::DeleteL() + { + CFileEntryList* entries = new(ELeave) CFileEntryList(32); + TInt operations = GetSelectedItemsOrCurrentItemL(entries); + CleanupStack::PushL(entries); + + CAknQueryDialog* query = CAknQueryDialog::NewL(); + _LIT(KQueryMessage, "Delete %d entries?"); + TFileName queryMsg; + queryMsg.Format(KQueryMessage, operations); + + if (query->ExecuteLD(R_GENERAL_CONFIRMATION_QUERY, queryMsg)) + { + // do the file operations for each entry + for (TInt i=0; iCount(); i++) + { + TFileEntry fileEntry = entries->At(i); + + // append the new command to the command array + if (fileEntry.iEntry.IsDir()) + { + AppendToCommandArrayL(EFileBrowserFileOpCommandDelete, + new(ELeave)CCommandParamsDelete(fileEntry, CFileMan::ERecurse) + ); + } + else + { + AppendToCommandArrayL(EFileBrowserFileOpCommandDelete, + new(ELeave)CCommandParamsDelete(fileEntry, 0) + ); + } + + } + + // execute all operations + StartExecutingCommandsL(_L("Deleting")); + } + + CleanupStack::PopAndDestroy(); //entries + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::TouchL() + { + CFileEntryList* entries = new(ELeave) CFileEntryList(32); + GetSelectedItemsOrCurrentItemL(entries); + CleanupStack::PushL(entries); + + TBool recurse(EFalse); + + // check if any directories and ask recursion + for (TInt i=0; iCount(); i++) + { + TFileEntry fileEntry = entries->At(i); + + if (fileEntry.iEntry.IsDir()) + { + CAknQueryDialog* query = CAknQueryDialog::NewL(); + if (query->ExecuteLD(R_GENERAL_CONFIRMATION_QUERY, _L("Recurse touch for all selected dirs?"))) + { + recurse = ETrue; + } + break; + } + } + + // now go through all entries + for (TInt i=0; iCount(); i++) + { + TFileEntry fileEntry = entries->At(i); + + // touch to current time + TTime now; + now.UniversalTime(); + + + // append the new command to the command array + if (fileEntry.iEntry.IsDir() && recurse) + { + AppendToCommandArrayL(EFileBrowserFileOpCommandAttribs, + new(ELeave)CCommandParamsAttribs(fileEntry, NULL, NULL, now, CFileMan::ERecurse) + ); + } + else + { + AppendToCommandArrayL(EFileBrowserFileOpCommandAttribs, + new(ELeave)CCommandParamsAttribs(fileEntry, NULL, NULL, now, 0) + ); + } + } + + // execute all operations + StartExecutingCommandsL(_L("Touching")); + + CleanupStack::PopAndDestroy(); //entries + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::RenameL() + { + CFileEntryList* entries = new(ELeave) CFileEntryList(16); + GetSelectedItemsOrCurrentItemL(entries); + CleanupStack::PushL(entries); + + for (TInt i=0; iCount(); i++) + { + TFileEntry fileEntry = entries->At(i); + + TFileName newName = fileEntry.iEntry.iName; + + CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL(newName); + textQuery->SetPromptL(_L("Enter new name:")); + + if (textQuery->ExecuteLD(R_GENERAL_TEXT_QUERY)) + { + TFileName targetEntry = fileEntry.iPath; + targetEntry.Append(newName); + + TBool alreadyExists(EFalse); + TBool doRenameOperation(ETrue); + + if (fileEntry.iEntry.IsDir()) + { + //targetEntry.Append(_L("\\")); + alreadyExists = BaflUtils::PathExists(iFs, targetEntry); + } + else + { + alreadyExists = BaflUtils::FileExists(iFs, targetEntry); + } + + if (alreadyExists) + { + CAknQueryDialog* query = CAknQueryDialog::NewL(); + _LIT(KQueryMessage, "%S already exists, overwrite?"); + TFileName queryMsg; + queryMsg.Format(KQueryMessage, &newName); + + if (!query->ExecuteLD(R_GENERAL_CONFIRMATION_QUERY, queryMsg)) + { + doRenameOperation = EFalse; + } + } + + if (doRenameOperation) + { + // append the new command to the command array + AppendToCommandArrayL(EFileBrowserFileOpCommandRename, + new(ELeave)CCommandParamsRename(fileEntry, targetEntry, CFileMan::EOverWrite) + ); + } + } + } + + // execute all operations + StartExecutingCommandsL(_L("Renaming")); + + CleanupStack::PopAndDestroy(); //entries + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::SetAttributesL() + { + CFileEntryList* entries = new(ELeave) CFileEntryList(16); + GetSelectedItemsOrCurrentItemL(entries); + CleanupStack::PushL(entries); + + if (entries->Count() > 0) + { + TFileName naviText = _L("Multiple entries"); + + TUint setAttMask(0); + TUint clearAttMask(0); + TBool recurse(EFalse); + + // set default masks if only one file selected + if (entries->Count() == 1) + { + TFileEntry fileEntry = entries->At(0); + + naviText.Copy(fileEntry.iEntry.iName); + + if (fileEntry.iEntry.IsArchive()) + setAttMask |= KEntryAttArchive; + else + clearAttMask |= KEntryAttArchive; + + if (fileEntry.iEntry.IsHidden()) + setAttMask |= KEntryAttHidden; + else + clearAttMask |= KEntryAttHidden; + + if (fileEntry.iEntry.IsReadOnly()) + setAttMask |= KEntryAttReadOnly; + else + clearAttMask |= KEntryAttReadOnly; + + if (fileEntry.iEntry.IsSystem()) + setAttMask |= KEntryAttSystem; + else + clearAttMask |= KEntryAttSystem; + } + + iModel->FileListContainer()->SetScreenLayoutL(EDisplayModeNormal); + iModel->FileListContainer()->SetNaviPaneTextL(naviText); + + CFileBrowserAttributeEditorDlg* dlg = CFileBrowserAttributeEditorDlg::NewL(setAttMask, clearAttMask, recurse); + TBool dlgResult = dlg->RunEditorLD(); + + iModel->FileListContainer()->SetScreenLayoutL(iModel->Settings().iDisplayMode); + iModel->FileListContainer()->SetNaviPaneTextL(iCurrentPath); + + if (dlgResult && (setAttMask > 0 || clearAttMask > 0)) + { + for (TInt i=0; iCount(); i++) + { + TFileEntry fileEntry = entries->At(i); + + // append the new command to the command array + if (fileEntry.iEntry.IsDir() && recurse) + { + AppendToCommandArrayL(EFileBrowserFileOpCommandAttribs, + new(ELeave)CCommandParamsAttribs(fileEntry, setAttMask, clearAttMask, fileEntry.iEntry.iModified, CFileMan::ERecurse) + ); + } + else + { + AppendToCommandArrayL(EFileBrowserFileOpCommandAttribs, + new(ELeave)CCommandParamsAttribs(fileEntry, setAttMask, clearAttMask, fileEntry.iEntry.iModified, 0) + ); + } + } + + // execute all operations + StartExecutingCommandsL(_L("Changing attributes")); + } + } + + CleanupStack::PopAndDestroy(); //entries + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::SearchL() + { + iModel->FileListContainer()->SetScreenLayoutL(EDisplayModeNormal); + iModel->FileListContainer()->SetNaviPaneTextL(KNullDesC); + + iSearchAttributes.iSearchDir = iCurrentPath; + + CFileBrowserSearchQueryDlg* dlg = CFileBrowserSearchQueryDlg::NewL(iSearchAttributes); + TBool dlgResult = dlg->RunQueryLD(); + + iModel->FileListContainer()->SetScreenLayoutL(iModel->Settings().iDisplayMode); + iModel->FileListContainer()->SetNaviPaneTextL(iCurrentPath); + + if (dlgResult) + { + iModel->EikonEnv()->BusyMsgL(_L("** Searching **"), TGulAlignment(EHCenterVTop)); + + iFileEntryList->Reset(); + + // if search dir is empty, find from all drives + if (iSearchAttributes.iSearchDir == KNullDesC) + { + for (TInt i=0; iCount(); i++) + { + TDriveEntry driveEntry = iDriveEntryList->At(i); + + TBuf<10> driveRoot; + driveRoot.Append(driveEntry.iLetter); + driveRoot.Append(_L(":\\")); + + DoSearchFiles(iSearchAttributes.iWildCards, driveRoot); + + if (iSearchAttributes.iRecurse) + DoSearchFilesRecursiveL(iSearchAttributes.iWildCards, driveRoot); + + } + + } + + // otherwise just search from the selected directory + else + { + DoSearchFiles(iSearchAttributes.iWildCards, iSearchAttributes.iSearchDir); + + if (iSearchAttributes.iRecurse) + DoSearchFilesRecursiveL(iSearchAttributes.iWildCards, iSearchAttributes.iSearchDir); + } + + iModel->EikonEnv()->BusyMsgCancel(); + + TInt operations = iFileEntryList->Count(); + + iListingMode = ESearchResults; + iModel->FileListContainer()->ListBox()->SetCurrentItemIndex(0); + RefreshViewL(); + + _LIT(KMessage, "%d entries found"); + TFileName noteMsg; + noteMsg.Format(KMessage, operations); + + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(noteMsg); + } + } + +// -------------------------------------------------------------------------------------------- + +TInt CFileBrowserFileUtils::DoSearchFiles(const TDesC& aFileName, const TDesC& aPath) + { + TFindFile fileFinder(iFs); + CDir* dir; + TInt err = fileFinder.FindWildByPath(aFileName, &aPath, dir); + + while (err == KErrNone) + { + for (TInt i=0; iCount(); i++) + { + TEntry entry = (*dir)[i]; + + TTime entryModified = entry.iModified; + // convert from universal time + if ( iTz.ConvertToLocalTime( entryModified ) == KErrNone ) + { + entryModified = entry.iModified; + } + if ((entry.IsDir() && entryModified >= iSearchAttributes.iMinDate && entryModified <= iSearchAttributes.iMaxDate) || + (!entry.IsDir() &&entry.iSize >= iSearchAttributes.iMinSize && entry.iSize <= iSearchAttributes.iMaxSize && + entryModified >= iSearchAttributes.iMinDate && entryModified <= iSearchAttributes.iMaxDate)) + { + TParse parsedName; + parsedName.Set(entry.iName, &fileFinder.File(), NULL); + + if (parsedName.Drive().Length() && aPath.Length() && parsedName.Drive()[0] == aPath[0]) + { + TFileEntry fileEntry; + fileEntry.iPath = parsedName.DriveAndPath(); + fileEntry.iEntry = entry; + fileEntry.iDirEntries = KErrNotFound; + + TBool appendToArray(EFalse); + + // append directories always + if (entry.IsDir() && !iSearchAttributes.iTextInFile.Length()) + { + fileEntry.iIconId = EFixedIconFolder; + appendToArray = ETrue; + } + + // normal file + else + { + fileEntry.iIconId = EFixedIconEmpty; + + // check if a string needs to be found inside the file + if (iSearchAttributes.iTextInFile.Length()) + { + // currently only 8-bit searching, so convert from 16-bit + TBuf8<256> searchText; + searchText.Copy(iSearchAttributes.iTextInFile); + + // specify buffer size and create a buffer + const TInt KReadBufSize = 1024*1024; + HBufC8* buffer = HBufC8::NewLC(KReadBufSize); + TPtr8 bufferPtr = buffer->Des(); + + // open the file for reading + RFile file; + if (file.Open(iFs, parsedName.FullName(), EFileRead) == KErrNone) + { + TInt currentPos(0); + + for (;;) + { + // read from the file + file.Read(currentPos, bufferPtr, KReadBufSize); + + // stop looping if the read buffer isn't long enough + if (bufferPtr.Length() < searchText.Length()) + { + break; + } + + // try to find the text + if (bufferPtr.FindF(searchText) >= 0) + { + // match found! + appendToArray = ETrue; + break; + } + + // calculate the next position + currentPos += KReadBufSize - searchText.Length(); + } + + file.Close(); + } + + CleanupStack::PopAndDestroy(); //buffer + } + else + { + appendToArray = ETrue; + } + } + + if (appendToArray) + TRAP(err, iFileEntryList->AppendL(fileEntry)); + } + } + } + + delete dir; + err = fileFinder.FindWild(dir); + } + + return err; + } + +// -------------------------------------------------------------------------------------------- + +TInt CFileBrowserFileUtils::DoSearchFilesRecursiveL(const TDesC& aFileName, const TDesC& aPath) + { + TInt err(KErrNone); + CDirScan* scan = CDirScan::NewLC(iFs); + scan->SetScanDataL(aPath, KEntryAttDir|KEntryAttMatchMask, ESortByName | EAscending | EDirsFirst); + CDir* dir = NULL; + + for(;;) + { + TRAP(err, scan->NextL(dir)); + if (!dir || (err != KErrNone)) + break; + + for (TInt i=0; iCount(); i++) + { + TEntry entry = (*dir)[i]; + + if (entry.IsDir()) + { + TFileName path(scan->FullPath()); + + if (path.Length()) + { + path.Append(entry.iName); + path.Append(_L("\\")); + DoSearchFiles(aFileName, path); + } + } + } + delete(dir); + } + + CleanupStack::PopAndDestroy(scan); + return err; + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::NewFileL() + { + TFileName newName; + + CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL(newName); + textQuery->SetPromptL(_L("Enter filename:")); + + if (textQuery->ExecuteLD(R_GENERAL_TEXT_QUERY)) + { + TFileName fullPath = iCurrentPath; + fullPath.Append(newName); + + TParse nameParser; + TInt err = nameParser.SetNoWild(fullPath, NULL, NULL); + + if (err == KErrNone) + { + // do not try to recreate the file if it already exists + if (BaflUtils::PathExists(iFs, nameParser.DriveAndPath())) + { + err = iFileOps->CreateEmptyFile(fullPath); + } + else + err = KErrAlreadyExists; + } + + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("New file created")); + } + + else if (err == KErrAlreadyExists) + { + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(_L("File already exists")); + } + + else + { + CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv()); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD( textResolver->ResolveErrorString(err, CTextResolver::ECtxNoCtxNoSeparator) ); + + CleanupStack::PopAndDestroy(); //textResolver + } + + RefreshViewL(); + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::NewDirectoryL() + { + TFileName newDirectory; + + CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL(newDirectory); + textQuery->SetPromptL(_L("Enter directory name:")); + + if (textQuery->ExecuteLD(R_GENERAL_TEXT_QUERY)) + { + TFileName fullPath = iCurrentPath; + fullPath.Append(newDirectory); + fullPath.Append(_L("\\")); + + TInt err = iFileOps->MkDirAll(fullPath, 0, ETrue); + + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("New directory created")); + } + + else if (err == KErrAlreadyExists) + { + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(_L("Directory already exists")); + } + + else + { + CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv()); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD( textResolver->ResolveErrorString(err, CTextResolver::ECtxNoCtxNoSeparator) ); + + CleanupStack::PopAndDestroy(); //textResolver + } + + RefreshViewL(); + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::SendToL() + { + CFileEntryList* entries = new(ELeave) CFileEntryList(32); + GetSelectedItemsOrCurrentItemL(entries); + CleanupStack::PushL(entries); + + TInt operations(0); + + CSendUi* sendUi = CSendUi::NewL(); + CleanupStack::PushL(sendUi); + CMessageData* messageData = CMessageData::NewL(); + CleanupStack::PushL(messageData); + + for (TInt i=0; iCount(); i++) + { + TFileEntry fileEntry = entries->At(i); + + // only supported for normal file entries + if (!fileEntry.iEntry.IsDir()) + { + TFileName fullPath = fileEntry.iPath; + fullPath.Append(fileEntry.iEntry.iName); + + messageData->AppendAttachmentL(fullPath); + operations++; + + } + } + + if (operations > 0) + { + sendUi->ShowQueryAndSendL(messageData, TSendingCapabilities(0, 0, TSendingCapabilities::ESupportsAttachments)); + + // I guess this note is not needed.. + /* + _LIT(KMessage, "%d entries sent"); + TFileName noteMsg; + noteMsg.Format(KMessage, operations); + + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(noteMsg); + */ + } + else + { + _LIT(KMessage, "Nothing to send"); + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(KMessage); + } + + CleanupStack::PopAndDestroy(3); // entries, sendUi, messageData + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::CompressL() + { + CFileEntryList* entries = new(ELeave) CFileEntryList(16); + GetSelectedItemsOrCurrentItemL(entries); + CleanupStack::PushL(entries); + + for (TInt i=0; iCount(); i++) + { + TFileEntry fileEntry = entries->At(i); + + TFileName sourceEntry = fileEntry.iPath; + sourceEntry.Append(fileEntry.iEntry.iName); + + TFileName targetEntry = sourceEntry; + targetEntry.Append(KGZipExt); + + TFileName targetEntryShort; + targetEntryShort.Copy(fileEntry.iEntry.iName); + targetEntryShort.Append(KGZipExt); + + if (BaflUtils::FileExists(iFs, targetEntry)) + { + _LIT(KMessage, "%S already exists"); + TFileName noteMsg; + noteMsg.Format(KMessage, &targetEntryShort); + + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(noteMsg); + } + else + { + TRAPD(err, + RFile inputFile; + User::LeaveIfError(inputFile.Open(iFs, sourceEntry, EFileStream | EFileRead | EFileShareAny)); + CleanupClosePushL(inputFile); + + CEZFileToGZip* gZip = CEZFileToGZip::NewLC(iFs, targetEntry, inputFile); + + while (gZip->DeflateL()) + ; + + CleanupStack::PopAndDestroy(2); //inputFile, gZip + ); + + if (err == KErrNone) + { + _LIT(KMessage, "%S created succesfully"); + TFileName noteMsg; + noteMsg.Format(KMessage, &targetEntryShort); + + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(noteMsg); + } + else + { + _LIT(KMessage, "Unable to create %S"); + TFileName noteMsg; + noteMsg.Format(KMessage, &targetEntryShort); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(noteMsg); + } + + RefreshViewL(); + } + } + + CleanupStack::PopAndDestroy(); //entries + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::DecompressL() + { + CFileEntryList* entries = new(ELeave) CFileEntryList(16); + GetSelectedItemsOrCurrentItemL(entries); + CleanupStack::PushL(entries); + + for (TInt i=0; iCount(); i++) + { + TFileEntry fileEntry = entries->At(i); + + TFileName sourceEntry = fileEntry.iPath; + sourceEntry.Append(fileEntry.iEntry.iName); + + TFileName targetEntry; + TFileName targetEntryShort; + + TInt sourceNameLen = fileEntry.iEntry.iName.Length(); + TInt gZipExtLen = KGZipExt().Length(); + + if (sourceNameLen > gZipExtLen && sourceEntry.Right(gZipExtLen).CompareF(KGZipExt) == 0) + { + targetEntry = sourceEntry.Left(sourceEntry.Length() - gZipExtLen); + targetEntryShort = fileEntry.iEntry.iName.Left(sourceNameLen - gZipExtLen); + + if (BaflUtils::FileExists(iFs, targetEntry)) + { + _LIT(KMessage, "%S already exists"); + TFileName noteMsg; + noteMsg.Format(KMessage, &targetEntryShort); + + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(noteMsg); + } + else + { + TRAPD(err, + RFile outputFile; + User::LeaveIfError(outputFile.Create(iFs, targetEntry, EFileStream | EFileWrite | EFileShareExclusive)); + CleanupClosePushL(outputFile); + + CEZGZipToFile* gZip = CEZGZipToFile::NewLC(iFs, sourceEntry, outputFile); + + while (gZip->InflateL()) + ; + + CleanupStack::PopAndDestroy(2); //outputFile, gZip + ); + + if (err == KErrNone) + { + _LIT(KMessage, "%S decompressed succesfully"); + TFileName noteMsg; + noteMsg.Format(KMessage, &fileEntry.iEntry.iName); + + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(noteMsg); + } + else + { + _LIT(KMessage, "Unable to decompress %S"); + TFileName noteMsg; + noteMsg.Format(KMessage, &fileEntry.iEntry.iName); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(noteMsg); + } + + RefreshViewL(); + } + } + else + { + _LIT(KMessage, "%S does not have %S extension"); + TFileName noteMsg; + noteMsg.Format(KMessage, &fileEntry.iEntry.iName, &KGZipExt); + + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(noteMsg); + } + } + + CleanupStack::PopAndDestroy(); //entries + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::PropertiesL() + { + TBool showDialog(EFalse); + + _LIT(KPropertiesEntryStr, "%S\t%S"); + _LIT(KPropertiesEntryInt, "%S\t%d"); + _LIT(KPropertiesEntryUintHex, "%S\t0x%x"); + + _LIT(KDateFormat, "%D%M%Y%/0%1%/1%2%/2%3%/3"); + _LIT(KTimeFormat, "%-B%:0%J%:1%T%:2%S%:3%+B"); + + _LIT(KMediaType, "Media"); + _LIT(KAttributes, "Atts"); + _LIT(KVolumeName, "Name"); + _LIT(KUniqueID, "ID"); + _LIT(KNumberOfEntries, "Entries"); + _LIT(KNumberOfFiles, "Files"); + _LIT(KUsed, "Used (B)"); + _LIT(KFree, "Free (B)"); + _LIT(KSize, "Size (B)"); + _LIT(KPath, "Path"); + _LIT(KDate, "Date"); + _LIT(KTime, "Time"); + _LIT(KMimeType, "Mime"); + _LIT(KOpensWith, "Opens"); + + + // create an array for the items + CDesCArray* entryLines = new(ELeave) CDesCArrayFlat(16); + CleanupStack::PushL(entryLines); + TFileName titleText; + + // just get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (IsDriveListViewActive() && iDriveEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + // it is a drive entry + TDriveEntry driveEntry = iDriveEntryList->At(currentItemIndex); + TFileName textEntry; + + // set title + titleText.Append(driveEntry.iLetter); + titleText.Append(_L(":")); + + // media type + textEntry.Format(KPropertiesEntryStr, &KMediaType, &driveEntry.iMediaTypeDesc); + entryLines->AppendL(textEntry); + + // attributes + textEntry.Format(KPropertiesEntryStr, &KAttributes, &driveEntry.iAttributesDesc); + entryLines->AppendL(textEntry); + + // volume name + if (driveEntry.iVolumeInfo.iName.Length()) + { + textEntry.Format(KPropertiesEntryStr, &KVolumeName, &driveEntry.iVolumeInfo.iName); + entryLines->AppendL(textEntry); + } + + // unique id + textEntry.Format(KPropertiesEntryUintHex, &KUniqueID, driveEntry.iVolumeInfo.iUniqueID); + entryLines->AppendL(textEntry); + + // number of files + if (iModel->Settings().iShowSubDirectoryInfo) + { + iFindFileEntryList->Reset(); + + TBuf<10> driveRoot; + driveRoot.Append(driveEntry.iLetter); + driveRoot.Append(_L(":\\")); + + DoFindFiles(_L("*"), driveRoot); + DoFindFilesRecursiveL(_L("*"), driveRoot); + + textEntry.Format(KPropertiesEntryInt, &KNumberOfFiles, iFindFileEntryList->Count()); + entryLines->AppendL(textEntry); + + iFindFileEntryList->Reset(); + } + + // used + TBuf<32> usedBuf; + usedBuf.AppendNum(driveEntry.iVolumeInfo.iSize-driveEntry.iVolumeInfo.iFree, TRealFormat(KDefaultRealWidth, 0)); + textEntry.Format(KPropertiesEntryStr, &KUsed, &usedBuf); + entryLines->AppendL(textEntry); + + // free + TBuf<32> freeBuf; + freeBuf.AppendNum(driveEntry.iVolumeInfo.iFree, TRealFormat(KDefaultRealWidth, 0)); + textEntry.Format(KPropertiesEntryStr, &KFree, &freeBuf); + entryLines->AppendL(textEntry); + + // size + TBuf<32> sizeBuf; + sizeBuf.AppendNum(driveEntry.iVolumeInfo.iSize, TRealFormat(KDefaultRealWidth, 0)); + textEntry.Format(KPropertiesEntryStr, &KSize, &sizeBuf); + entryLines->AppendL(textEntry); + + showDialog = ETrue; + } + + else if (iFileEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + // it is a file or a directory entry + TFileEntry fileEntry = iFileEntryList->At(currentItemIndex); + TFileName textEntry; + + // set title + titleText.Append(fileEntry.iEntry.iName); + + // path + textEntry.Format(KPropertiesEntryStr, &KPath, &fileEntry.iPath); + entryLines->AppendL(textEntry); + + // date + TTime entryModified = fileEntry.iEntry.iModified; + + // convert from universal time + if ( iTz.ConvertToLocalTime( entryModified ) == KErrNone ) + { + entryModified = fileEntry.iEntry.iModified; // use universal time + } + + TBuf<32> dateBuf; + entryModified.FormatL(dateBuf, KDateFormat); + textEntry.Format(KPropertiesEntryStr, &KDate, &dateBuf); + entryLines->AppendL(textEntry); + + // time + TBuf<32> timeBuf; + entryModified.FormatL(timeBuf, KTimeFormat); + textEntry.Format(KPropertiesEntryStr, &KTime, &timeBuf); + entryLines->AppendL(textEntry); + + if (!fileEntry.iEntry.IsDir()) + { + // size + TBuf<32> sizeBuf; + sizeBuf.AppendNum(fileEntry.iEntry.iSize, TRealFormat(KDefaultRealWidth, 0)); + textEntry.Format(KPropertiesEntryStr, &KSize, &sizeBuf); + entryLines->AppendL(textEntry); + } + else if (fileEntry.iEntry.IsDir() && iModel->Settings().iShowSubDirectoryInfo) + { + iFindFileEntryList->Reset(); + + TFileName fullPath; + fullPath.Append(fileEntry.iPath); + fullPath.Append(fileEntry.iEntry.iName); + fullPath.Append(_L("\\")); + + // number of entries + CDir* subDir = NULL; + if (iFs.GetDir(fullPath, KEntryAttMatchMask, ESortNone | EDirsFirst, subDir) == KErrNone) + { + CleanupStack::PushL(subDir); + textEntry.Format(KPropertiesEntryInt, &KNumberOfEntries, subDir->Count()); + entryLines->AppendL(textEntry); + CleanupStack::PopAndDestroy(); //subDir + } + + // number of files + DoFindFiles(_L("*"), fullPath); + DoFindFilesRecursiveL(_L("*"), fullPath); + textEntry.Format(KPropertiesEntryInt, &KNumberOfFiles, iFindFileEntryList->Count()); + entryLines->AppendL(textEntry); + + // size + TInt64 size(0); + for (TInt i=0; iCount(); i++) + { + TFileEntry fileEntry = iFindFileEntryList->At(i); + size += fileEntry.iEntry.iSize; + } + + TBuf<32> sizeBuf; + sizeBuf.AppendNum(size, TRealFormat(KDefaultRealWidth, 0)); + textEntry.Format(KPropertiesEntryStr, &KSize, &sizeBuf); + entryLines->AppendL(textEntry); + + iFindFileEntryList->Reset(); + } + + // attributes + TBuf<32> attBuf; + if (fileEntry.iEntry.IsArchive()) + attBuf.Append(_L("Arc ")); + if (fileEntry.iEntry.IsHidden()) + attBuf.Append(_L("Hid ")); + if (fileEntry.iEntry.IsReadOnly()) + attBuf.Append(_L("R/O ")); + if (fileEntry.iEntry.IsSystem()) + attBuf.Append(_L("Sys")); + textEntry.Format(KPropertiesEntryStr, &KAttributes, &attBuf); + entryLines->AppendL(textEntry); + + if (!fileEntry.iEntry.IsDir()) + { + // mime type + TFileName fullPath = fileEntry.iPath; + fullPath.Append(fileEntry.iEntry.iName); + TDataType dataType; + TUid appUid; + if (iModel->LsSession().AppForDocument(fullPath, appUid, dataType) == KErrNone) + { + TBuf<128> mimeTypeBuf; + mimeTypeBuf.Copy(dataType.Des8()); + if (mimeTypeBuf == KNullDesC) + mimeTypeBuf.Copy(_L("N/A")); + textEntry.Format(KPropertiesEntryStr, &KMimeType, &mimeTypeBuf); + entryLines->AppendL(textEntry); + } + + // opens with + TApaAppInfo appInfo; + if (iModel->LsSession().GetAppInfo(appInfo, appUid) == KErrNone) + { + TFileName opensWithBuf; + _LIT(KOpensWithFormat, "%S (0x%08X)"); + opensWithBuf.Format(KOpensWithFormat, &appInfo.iCaption, appInfo.iUid); + textEntry.Format(KPropertiesEntryStr, &KOpensWith, &opensWithBuf); + entryLines->AppendL(textEntry); + } + } + + showDialog = ETrue; + } + + + if (showDialog) + { + CAknSingleHeadingPopupMenuStyleListBox* listBox = new(ELeave) CAknSingleHeadingPopupMenuStyleListBox; + CleanupStack::PushL(listBox); + + CAknPopupList* popupList = CAknPopupList::NewL(listBox, R_AVKON_SOFTKEYS_OK_EMPTY, AknPopupLayouts::EMenuDoubleWindow); + CleanupStack::PushL(popupList); + + listBox->ConstructL(popupList, CEikListBox::ELeftDownInViewRect); + listBox->ItemDrawer()->ColumnData()->EnableMarqueeL(ETrue); + listBox->CreateScrollBarFrameL(ETrue); + listBox->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto); + listBox->Model()->SetItemTextArray(entryLines); + listBox->Model()->SetOwnershipType(ELbmDoesNotOwnItemArray); + listBox->HandleItemAdditionL(); + + popupList->SetTitleL(titleText); + popupList->ExecuteLD(); + + CleanupStack::Pop(); // popupList + CleanupStack::PopAndDestroy(); // listBox + } + + CleanupStack::PopAndDestroy(); //entryLines + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::OpenWithApparcL() + { + // just get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iFileEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TFileEntry fileEntry = iFileEntryList->At(currentItemIndex); + + TFileName fullPath = fileEntry.iPath; + fullPath.Append(fileEntry.iEntry.iName); + + TInt err1(KErrNone), err2(KErrNone); + TUid appUid; + TDataType dataType; + TBool isProgram; + + err1 = iModel->LsSession().AppForDocument(fullPath, appUid, dataType); + err2 = iModel->LsSession().IsProgram(fullPath, isProgram); + + if (err1 == KErrNone && err2 == KErrNone) + { + if (appUid != KNullUid) + { + // found an app, run using it + TApaTaskList taskList(iModel->EikonEnv()->WsSession()); + TApaTask task = (taskList.FindApp(appUid)); + if (task.Exists()) + { + User::LeaveIfError(task.SwitchOpenFile(fullPath)); + task.BringToForeground(); + } + else + { + TThreadId id; + iModel->LsSession().StartDocument(fullPath, appUid, id, RApaLsSession::ESwitchFiles); + } + } + else if (isProgram) + { + LaunchProgramL(fullPath); + } + } + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::HandleServerAppExit(TInt aReason) + { + if (iOpenFileService) + { + delete iOpenFileService; + iOpenFileService = NULL; + } + MAknServerAppExitObserver::HandleServerAppExit(aReason); + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::OpenWithDocHandlerL(TBool aEmbed) + { + // just get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iFileEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TFileEntry fileEntry = iFileEntryList->At(currentItemIndex); + + TFileName fullPath = fileEntry.iPath; + fullPath.Append(fileEntry.iEntry.iName); + + RFile sharableFile; + iDocHandler->OpenTempFileL(fullPath, sharableFile); + CleanupClosePushL(sharableFile); + TDataType dataType; + if (aEmbed) + iDocHandler->OpenFileEmbeddedL(sharableFile, dataType); + else + iDocHandler->OpenFileL(sharableFile, dataType); + CleanupStack::PopAndDestroy(); //sharableFile + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::OpenWithFileServiceL() + { + // just get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iFileEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TFileEntry fileEntry = iFileEntryList->At(currentItemIndex); + + TFileName fullPath = fileEntry.iPath; + fullPath.Append(fileEntry.iEntry.iName); + + TBool itemSelected(EFalse); + RFile sharableFile; + TUid appUidExtracted; + + TRAPD(err, + + // use doc handler to get a sharable file handle + iDocHandler->OpenTempFileL(fullPath, sharableFile); + CleanupClosePushL(sharableFile); + + // find the data type + TDataRecognitionResult dataType; + User::LeaveIfError(iModel->LsSession().RecognizeData(sharableFile, dataType)); + + // get all apps that support OpenFileService for this datatype + CApaAppServiceInfoArray* apps = iModel->LsSession().GetServiceImplementationsLC(KOpenServiceUid, dataType.iDataType); + TArray appServiceInfos = apps->Array(); + + if (appServiceInfos.Count() > 0) + { + // build an array of the app names + CDesCArray* names = new (ELeave) CDesCArrayFlat(16); + CleanupStack::PushL(names); + for (TInt ii=0; iiLsSession().GetAppInfo(appInfo, appUid) == KErrNone) + { + names->AppendL(appInfo.iCaption); + } + else + { + TBuf<10> buf; + buf.Format(_L("0x%08x"), appUid); + names->AppendL(buf); + } + } + + // use a list query to select the app + TInt index(0); + CAknListQueryDialog* dlg = new(ELeave) CAknListQueryDialog(&index); + dlg->PrepareLC(R_APP_SELECTION_QUERY); + dlg->SetItemTextArray(names); + dlg->SetOwnershipType(ELbmDoesNotOwnItemArray); + + if(dlg->RunLD()) + { + // extract the chosen UID + appUidExtracted = appServiceInfos[index].Uid(); + itemSelected = ETrue; + } + + CleanupStack::PopAndDestroy(); // names + } + + if (itemSelected) + { + // start OpenFileService for the selected app + CAiwGenericParamList& paramList = iDocHandler->InParamListL(); + + if (iOpenFileService) + { + delete iOpenFileService; + iOpenFileService = NULL; + } + + iOpenFileService = CAknOpenFileService::NewL(appUidExtracted, sharableFile, this, ¶mList); + } + + CleanupStack::PopAndDestroy(2); // sharableFile, apps + + ); // TRAPD + + if (err != KErrNone) + { + _LIT(KMessage, "No file service available for %S"); + TFileName noteMsg; + noteMsg.Format(KMessage, &fileEntry.iEntry.iName); + + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(noteMsg); + } + } + } + +// -------------------------------------------------------------------------------------------- + +TBool CFileBrowserFileUtils::FileExists(const TDesC& aPath) + { + return BaflUtils::FileExists(iFs, aPath); + } + +// -------------------------------------------------------------------------------------------- + +TInt CFileBrowserFileUtils::LaunchProgramL(const TDesC& aPath) + { + CApaCommandLine* commandLine = CApaCommandLine::NewLC(); + commandLine->SetExecutableNameL(aPath); + commandLine->SetCommandL(EApaCommandRun); + TInt err = iModel->LsSession().StartApp(*commandLine); + CleanupStack::PopAndDestroy(); //commandLine + return err; + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::MemoryInfoPopupL() + { + _LIT(KUsedBytesEntry, "Used: %S bytes\n"); + _LIT(KFreeBytesEntry, "Free: %S bytes\n"); + _LIT(KSizeBytesEntry, "Size: %S bytes\n"); + + HBufC* messageBuf = HBufC::NewLC(2048); + TPtr messagePtr = messageBuf->Des(); + TBuf<128> entryLine; + + // RAM + TMemoryInfoV1Buf ramMemory; + UserHal::MemoryInfo(ramMemory); + messagePtr.Append(_L("RAM\n")); + + // used + TBuf<32> usedBuf; + usedBuf.AppendNum(ramMemory().iMaxFreeRamInBytes-ramMemory().iFreeRamInBytes, TRealFormat(KDefaultRealWidth, 0)); + entryLine.Format(KUsedBytesEntry, &usedBuf); + messagePtr.Append(entryLine); + + // free + TBuf<32> freeBuf; + freeBuf.AppendNum(ramMemory().iFreeRamInBytes, TRealFormat(KDefaultRealWidth, 0)); + entryLine.Format(KFreeBytesEntry, &freeBuf); + messagePtr.Append(entryLine); + + // size + TBuf<32> sizeBuf; + sizeBuf.AppendNum(ramMemory().iMaxFreeRamInBytes, TRealFormat(KDefaultRealWidth, 0)); + entryLine.Format(KSizeBytesEntry, &sizeBuf); + messagePtr.Append(entryLine); + + // All drives + for (TInt i=0; iCount(); i++) + { + TDriveEntry driveEntry = iDriveEntryList->At(i); + + messagePtr.Append(_L("\n")); + messagePtr.Append(driveEntry.iLetter); + messagePtr.Append(_L(":\n")); + + // used + TBuf<32> usedBuf; + usedBuf.AppendNum(driveEntry.iVolumeInfo.iSize-driveEntry.iVolumeInfo.iFree, TRealFormat(KDefaultRealWidth, 0)); + entryLine.Format(KUsedBytesEntry, &usedBuf); + messagePtr.Append(entryLine); + + // free + TBuf<32> freeBuf; + freeBuf.AppendNum(driveEntry.iVolumeInfo.iFree, TRealFormat(KDefaultRealWidth, 0)); + entryLine.Format(KFreeBytesEntry, &freeBuf); + messagePtr.Append(entryLine); + + // size + TBuf<32> sizeBuf; + sizeBuf.AppendNum(driveEntry.iVolumeInfo.iSize, TRealFormat(KDefaultRealWidth, 0)); + entryLine.Format(KSizeBytesEntry, &sizeBuf); + messagePtr.Append(entryLine); + } + + CAknMessageQueryDialog* dialog = new(ELeave) CAknMessageQueryDialog; + dialog->PrepareLC(R_MEMORYINFO_DIALOG); + dialog->SetMessageTextL(messagePtr); + dialog->RunLD(); + + CleanupStack::PopAndDestroy(); //messageBuf + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::ShowFileCheckSumsL(TInt aType) + { + // get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iFileEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TFileEntry fileEntry = iFileEntryList->At(currentItemIndex); + TFileName fullPath = fileEntry.iPath; + fullPath.Append(fileEntry.iEntry.iName); + + // try to open the file for reading + RFile fileP; + TInt err = fileP.Open(iModel->EikonEnv()->FsSession(), fullPath, EFileRead|EFileShareReadersOnly); + + if (err == KErrNone) + { + CleanupClosePushL(fileP); + + TBuf<128> checkSum; + HBufC* messageBuf = HBufC::NewLC(2048); + TPtr messagePtr = messageBuf->Des(); + + // get MD5 checksum + if (aType == EFileBrowserCmdFileChecksumsMD5) + { + CMD5* md5 = CMD5::NewL(); + CleanupStack::PushL(md5); + HBufC8* md5Buf = MessageDigestInHexLC(md5, fileP); + checkSum.Copy(*md5Buf); + messagePtr.Append(_L("MD5\n")); + messagePtr.Append(checkSum); + CleanupStack::PopAndDestroy(2); // md5, md5Buf + } + + // get MD2 checksum + else if (aType == EFileBrowserCmdFileChecksumsMD2) + { + CMD2* md2 = CMD2::NewL(); + CleanupStack::PushL(md2); + HBufC8* md2Buf = MessageDigestInHexLC(md2, fileP); + checkSum.Copy(*md2Buf); + messagePtr.Append(_L("MD2\n")); + messagePtr.Append(checkSum); + CleanupStack::PopAndDestroy(2); // md2, md2Buf + } + + // get SHA-1 checksum + else if (aType == EFileBrowserCmdFileChecksumsSHA1) + { + CSHA1* sha1 = CSHA1::NewL(); + CleanupStack::PushL(sha1); + HBufC8* sha1Buf = MessageDigestInHexLC(sha1, fileP); + checkSum.Copy(*sha1Buf); + messagePtr.Append(_L("SHA-1\n")); + messagePtr.Append(checkSum); + CleanupStack::PopAndDestroy(2); // sha1, sha1Buf + } + + else + { + User::Panic(_L("Inv.CS.Type"), 723); + } + + // show dialog + CAknMessageQueryDialog* dialog = new(ELeave) CAknMessageQueryDialog; + dialog->PrepareLC(R_CHECKSUMS_DIALOG); + dialog->SetMessageTextL(messagePtr); + dialog->SetHeaderTextL(fileEntry.iEntry.iName); + dialog->RunLD(); + + CleanupStack::PopAndDestroy(2); // messageBuf, fileP + } + else + { + // open failed, show an error note + CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv()); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD( textResolver->ResolveErrorString(err, CTextResolver::ECtxNoCtxNoSeparator) ); + + CleanupStack::PopAndDestroy(); //textResolver + } + + } + } + +// -------------------------------------------------------------------------------------------- + +HBufC8* CFileBrowserFileUtils::MessageDigestInHexLC(CMessageDigest* aMD, RFile& aFile) + { + // seek to file start + TInt startPos(0); + aFile.Seek(ESeekStart, startPos); + + // create result buffer + HBufC8* result = HBufC8::NewLC(128); + + const TInt KBufSize(1024); + TInt fileSize(0); + TInt fileOffset(0); + + // get file size + aFile.Size(fileSize); + + HBufC8* buf = HBufC8::NewMaxLC(KBufSize); + TPtr8 bufPtr(buf->Des()); + + // read to buffer + while (fileOffset < fileSize - KBufSize) + { + aFile.Read(bufPtr, KBufSize); + aMD->Hash(bufPtr); + fileOffset += bufPtr.Length(); + } + + aFile.Read(bufPtr, fileSize - fileOffset); + bufPtr.SetLength(fileSize - fileOffset); + + // get final message digest + TPtrC8 hashedSig(aMD->Final(bufPtr)); + + // change size of the result buffer + result->ReAllocL(hashedSig.Length() * 2); + TPtr8 resultPtr = result->Des(); + + // convert to hex format + for (TInt i=0; iSettings().iBypassPlatformSecurity) + { + TInt err(KErrNone); + + if (aEnable) + { + // make sure that the directory exists + iFileOps->MkDirAll(KErrRdPath); + + // create the file + err = iFileOps->CreateEmptyFile(KErrRdPath); + } + else + { + // get TEntry of ErrRd + TEntry entry; + err = iFs.Entry(KErrRdPath, entry); + + if (err == KErrNone) + { + TFileEntry fileEntry; + fileEntry.iPath = KErrRdDir; + fileEntry.iEntry = entry; + + err = iFileOps->Delete(fileEntry); + } + } + + // update view + RefreshViewL(); + + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("State changed")); + } + else + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Cannot change the state")); + } + } + else + { + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(_L("Enable \"bypass platform security\" from the settings first")); + } + #else + aEnable = aEnable; + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(_L("Not supported in lite version")); + #endif + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::EnableAvkonIconCacheL(TBool aEnable) + { +#ifndef __SERIES60_30__ + if (AknIconConfig::EnableAknIconSrvCache(aEnable) == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("State changed")); + } + else + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Unknown error occured")); + } + #else + aEnable = aEnable; + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(_L("Not supported in S60 3.0")); + #endif + + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::SimulateLeaveL() + { + TInt leaveCode(-6); + + CAknNumberQueryDialog* numberQuery = CAknNumberQueryDialog::NewL(leaveCode); + numberQuery->SetPromptL(_L("Leave code")); + + if (numberQuery->ExecuteLD(R_GENERAL_NUMERIC_QUERY)) + { + User::Leave(leaveCode); + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::SimulatePanicL() + { + TInt panicCode(555); + TBuf<128> panicCategory; + panicCategory.Copy(_L("Test Category")); + + CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL(panicCategory); + textQuery->SetPromptL(_L("Panic category")); + + if (textQuery->ExecuteLD(R_GENERAL_TEXT_QUERY)) + { + CAknNumberQueryDialog* numberQuery = CAknNumberQueryDialog::NewL(panicCode); + numberQuery->SetPromptL(_L("Panic code")); + + if (numberQuery->ExecuteLD(R_GENERAL_NUMERIC_QUERY)) + { + User::Panic(panicCategory, panicCode); + } + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::SimulateExceptionL() + { + TInt exceptionCode(0); + + CAknNumberQueryDialog* numberQuery = CAknNumberQueryDialog::NewL(exceptionCode); + numberQuery->SetPromptL(_L("Exception code")); + + if (numberQuery->ExecuteLD(R_GENERAL_NUMERIC_QUERY)) + { + User::RaiseException((TExcType)exceptionCode); + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::SetDebugMaskL() + { + // get current debug mask + TUint32 dbgMask = UserSvr::DebugMask(); + + // convert the value in hex format + TBuf<64> hexBuf; + hexBuf.Copy(_L("0x")); + hexBuf.AppendNum(dbgMask, EHex); + + // do the query + CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL(hexBuf); + textQuery->SetPromptL(_L("Kernel debug mask in hex format")); + + if (textQuery->ExecuteLD(R_GENERAL_TEXT_QUERY)) + { + // check value + if (hexBuf.Length() > 2 && hexBuf[0]=='0' && hexBuf[1]=='x') + { + // remove 0x from the beginning + hexBuf.Copy(hexBuf.Right(hexBuf.Length()-2)); + + // convert the string back to decimal + TLex converter; + converter.Assign(hexBuf); + + if (converter.Val(dbgMask, EHex) == KErrNone) + { + User::SetDebugMask(dbgMask); + + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("Changed")); + } + else + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Cannot convert value")); + } + } + else + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Not in hex format")); + } + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::WriteAllAppsL() + { + _LIT(KAllAppsFileName, "AllApps.txt"); + TFileName allAppsPath = PathInfo::PhoneMemoryRootPath(); + allAppsPath.Append(KAllAppsFileName); + + RFile file; + if (file.Replace(iFs, allAppsPath, EFileWrite) == KErrNone) + { + CleanupClosePushL(file); + + CDesC8Array* appsArray = new(ELeave) CDesC8ArrayFlat(192); + CleanupStack::PushL(appsArray); + + TBuf8 fileEntry; + TBuf8 appFullPath; + _LIT8(KAppEntryFormat, "%S (0x%08X)%S"); + TApaAppInfo appInfo; + + iModel->LsSession().GetAllApps(); + + while (iModel->LsSession().GetNextApp(appInfo) == KErrNone) + { + appFullPath.Copy(appInfo.iFullName); + fileEntry.Format(KAppEntryFormat, &appFullPath, appInfo.iUid, &KFileNewLine); + appsArray->AppendL(fileEntry); + } + + appsArray->Sort(); + + for (TInt i=0; iCount(); i++) + { + file.Write(appsArray->MdcaPoint(i)); + } + + CleanupStack::PopAndDestroy(2); //appsArray, file + + _LIT(KMessage, "App list written to %S"); + TFileName noteMsg; + noteMsg.Format(KMessage, &allAppsPath); + + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote(); + note->SetTimeout(CAknNoteDialog::ENoTimeout); + note->ExecuteLD(noteMsg); + } + else + { + _LIT(KMessage, "Failed writing to %S"); + TFileName noteMsg; + noteMsg.Format(KMessage, &allAppsPath); + + CAknErrorNote* note = new(ELeave) CAknErrorNote(); + note->SetTimeout(CAknNoteDialog::ENoTimeout); + note->ExecuteLD(noteMsg); + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::WriteAllFilesL() + { + _LIT(KAllFilesFileName, "AllFiles.txt"); + TFileName allFilesPath = PathInfo::PhoneMemoryRootPath(); + allFilesPath.Append(KAllFilesFileName); + + RFile file; + if (file.Replace(iFs, allFilesPath, EFileWrite) == KErrNone) + { + CleanupClosePushL(file); + iFindFileEntryList->Reset(); + + iModel->EikonEnv()->BusyMsgL(_L("** Generating **"), TGulAlignment(EHCenterVTop)); + + for (TInt i=0; iCount(); i++) + { + TDriveEntry driveEntry = iDriveEntryList->At(i); + + TBuf<10> driveRoot; + driveRoot.Append(driveEntry.iLetter); + driveRoot.Append(_L(":\\")); + + // current dir + DoFindFiles(_L("*"), driveRoot); + + // recurse into sub directories + DoFindFilesRecursiveL(_L("*"), driveRoot); + } + + // write entries + TBuf8 writeBuf; + for (TInt i=0; iCount(); i++) + { + TFileEntry fileEntry = iFindFileEntryList->At(i); + + writeBuf.Copy(fileEntry.iPath); + writeBuf.Append(fileEntry.iEntry.iName); + writeBuf.Append(KFileNewLine); + + file.Write(writeBuf); + } + + iModel->EikonEnv()->BusyMsgCancel(); + + CleanupStack::PopAndDestroy(); //file + iFindFileEntryList->Reset(); + + _LIT(KMessage, "File list written to %S"); + TFileName noteMsg; + noteMsg.Format(KMessage, &allFilesPath); + + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote(); + note->SetTimeout(CAknNoteDialog::ENoTimeout); + note->ExecuteLD(noteMsg); + } + else + { + _LIT(KMessage, "Failed writing to %S"); + TFileName noteMsg; + noteMsg.Format(KMessage, &allFilesPath); + + CAknErrorNote* note = new(ELeave) CAknErrorNote(); + note->SetTimeout(CAknNoteDialog::ENoTimeout); + note->ExecuteLD(noteMsg); + } + } + +// -------------------------------------------------------------------------------------------- + +TInt CFileBrowserFileUtils::DoFindFiles(const TDesC& aFileName, const TDesC& aPath) + { + TFindFile fileFinder(iFs); + CDir* dir; + TInt err = fileFinder.FindWildByPath(aFileName, &aPath, dir); + + while (err == KErrNone) + { + for (TInt i=0; iCount(); i++) + { + TEntry entry = (*dir)[i]; + + // ignore any directory entries + if (!entry.IsDir() && entry.iName.Length() && aPath.Length()) + { + TParse parsedName; + parsedName.Set(entry.iName, &fileFinder.File(), NULL); + + if (parsedName.Drive().Length() && aPath.Length() && parsedName.Drive()[0] == aPath[0]) + { + TFileEntry fileEntry; + fileEntry.iPath = parsedName.DriveAndPath(); + fileEntry.iEntry = entry; + fileEntry.iDirEntries = KErrNotFound; + fileEntry.iIconId = EFixedIconEmpty; + + TRAP(err, iFindFileEntryList->AppendL(fileEntry)); + } + } + } + + delete dir; + dir = NULL; + err = fileFinder.FindWild(dir); + } + + return err; + } + +// -------------------------------------------------------------------------------------------- + +TInt CFileBrowserFileUtils::DoFindFilesRecursiveL(const TDesC& aFileName, const TDesC& aPath) + { + TInt err(KErrNone); + CDirScan* scan = CDirScan::NewLC(iFs); + scan->SetScanDataL(aPath, KEntryAttDir|KEntryAttMatchMask, ESortByName | EAscending | EDirsFirst); + CDir* dir = NULL; + + for(;;) + { + TRAP(err, scan->NextL(dir)); + if (!dir || (err != KErrNone)) + break; + + for (TInt i=0; iCount(); i++) + { + TEntry entry = (*dir)[i]; + + if (entry.IsDir()) + { + TFileName path(scan->FullPath()); + + if (path.Length()) + { + path.Append(entry.iName); + path.Append(_L("\\")); + DoFindFiles(aFileName, path); + } + } + } + delete(dir); + } + + CleanupStack::PopAndDestroy(scan); + return err; + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::ListOpenFilesL() + { + iFileEntryList->Reset(); + + CFileList* dir = NULL; + TOpenFileScan fileScan(iFs); + fileScan.NextL(dir); + + while (dir) + { + for (TInt i=0; iCount(); i++) + { + TEntry entry = (*dir)[i]; + TFileName fullPath; + + // TOpenFileScan does not return drive letters for the entries, so try to guess it + if (entry.iName.Length() > 2 && entry.iName[1] != ':') + { + for (TInt i=0; iCount(); i++) + { + TDriveEntry driveEntry = iDriveEntryList->At(i); + + TFileName guessPath; + guessPath.Append(driveEntry.iLetter); + guessPath.Append(_L(":")); + guessPath.Append(entry.iName); + + // check if the file exists + if (BaflUtils::FileExists(iFs, guessPath)) + { + // if it's on read only drive, then take it or check if it's really in use + TBool readOnlyDrive(ETrue); + BaflUtils::DiskIsReadOnly(iFs, guessPath, readOnlyDrive); + + if (readOnlyDrive || iFs.SetEntry(guessPath, entry.iModified, NULL, NULL) == KErrInUse) + { + fullPath = guessPath; + break; + } + } + } + } + else + { + fullPath = entry.iName; + } + + TParse nameParser; + if (fullPath.Length() && nameParser.SetNoWild(fullPath, NULL, NULL) == KErrNone) + { + entry.iName = nameParser.NameAndExt(); + + TFileEntry fileEntry; + fileEntry.iPath = nameParser.DriveAndPath(); + fileEntry.iEntry = entry; + fileEntry.iDirEntries = KErrNotFound; + fileEntry.iIconId = EFixedIconEmpty; + + iFileEntryList->AppendL(fileEntry); + } + } + + delete dir; + dir = NULL; + fileScan.NextL(dir); + } + + TInt operations = iFileEntryList->Count(); + + iListingMode = EOpenFiles; + iModel->FileListContainer()->ListBox()->SetCurrentItemIndex(0); + RefreshViewL(); + + _LIT(KMessage, "%d open files found"); + TFileName noteMsg; + noteMsg.Format(KMessage, operations); + + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(noteMsg); + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::ListMessageAttachmentsL(TInt aType) + { + iFileEntryList->Reset(); + + CMsvSession* session = CMsvSession::OpenSyncL(*this); + CleanupStack::PushL(session); + + CMsvEntry* context = NULL; + + if (aType == EFileBrowserCmdToolsMsgAttachmentsInbox) + context = session->GetEntryL(KMsvGlobalInBoxIndexEntryId); + else if (aType == EFileBrowserCmdToolsMsgAttachmentsDrafts) + context = session->GetEntryL(KMsvDraftEntryId); + else if (aType == EFileBrowserCmdToolsMsgAttachmentsSentItems) + context = session->GetEntryL(KMsvSentEntryId); + else if (aType == EFileBrowserCmdToolsMsgAttachmentsOutbox) + context = session->GetEntryL(KMsvGlobalOutBoxIndexEntryId); + else + User::Panic(_L("MsgAtt.Mode"), 100); + + CleanupStack::PushL(context); + + CDesCArray* attPaths = new(ELeave) CDesCArrayFlat(128); + CleanupStack::PushL(attPaths); + + // read attachment paths + ReadAttachmentPathsRecursiveL(session, context, attPaths); + + // create file entries of the paths + for (TInt i=0; iMdcaCount(); i++) + { + TFileEntry fileEntry; + TEntry entry; + TParse nameParser; + + if (attPaths->MdcaPoint(i).Length() && + nameParser.SetNoWild(attPaths->MdcaPoint(i), NULL, NULL) == KErrNone && + iFs.Entry(attPaths->MdcaPoint(i), entry) == KErrNone) + { + TFileEntry fileEntry; + fileEntry.iPath = nameParser.DriveAndPath(); + fileEntry.iEntry = entry; + fileEntry.iDirEntries = KErrNotFound; + fileEntry.iIconId = EFixedIconEmpty; + + iFileEntryList->AppendL(fileEntry); + } + } + + CleanupStack::PopAndDestroy(3); //session, context, attPaths + + TInt operations = iFileEntryList->Count(); + + if (aType == EFileBrowserCmdToolsMsgAttachmentsInbox) + iListingMode = EMsgAttachmentsInbox; + else if (aType == EFileBrowserCmdToolsMsgAttachmentsDrafts) + iListingMode = EMsgAttachmentsDrafts; + else if (aType == EFileBrowserCmdToolsMsgAttachmentsSentItems) + iListingMode = EMsgAttachmentsSentItems; + else if (aType == EFileBrowserCmdToolsMsgAttachmentsOutbox) + iListingMode = EMsgAttachmentsOutbox; + + iModel->FileListContainer()->ListBox()->SetCurrentItemIndex(0); + RefreshViewL(); + + _LIT(KMessage, "%d files found"); + TFileName noteMsg; + noteMsg.Format(KMessage, operations); + + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(noteMsg); + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::ReadAttachmentPathsRecursiveL(CMsvSession* aSession, CMsvEntry* aContext, CDesCArray* aAttPaths) + { + CMsvEntrySelection* entrySelection = aContext->ChildrenL(); + CleanupStack::PushL(entrySelection); + + for (TInt i=0; iCount(); i++) + { + CMsvEntry* entry = aSession->GetEntryL((*entrySelection)[i]); + CleanupStack::PushL(entry); + + CMsvStore* store = NULL; + TRAPD(err, store = entry->ReadStoreL()); + + if (err == KErrNone) + { + CleanupStack::PushL(store); + + for (TInt j=0; jAttachmentManagerL().AttachmentCount(); j++) + { + CMsvAttachment* attachment = store->AttachmentManagerL().GetAttachmentInfoL(j); + CleanupStack::PushL(attachment); + + aAttPaths->AppendL(attachment->FilePath()); + + CleanupStack::PopAndDestroy(); //attachment + } + CleanupStack::PopAndDestroy(); // store + } + + // recurse into children + if (entry->Count() > 0) + { + ReadAttachmentPathsRecursiveL(aSession, entry, aAttPaths); + } + + CleanupStack::PopAndDestroy(); // entry + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::WriteMsgStoreWalkL() + { + _LIT(KAllAppsFileName, "MsgStoreWalk.txt"); + TFileName allAppsPath = PathInfo::PhoneMemoryRootPath(); + allAppsPath.Append(KAllAppsFileName); + + if (iMsgStoreWalkFile.Replace(iFs, allAppsPath, EFileWrite) == KErrNone) + { + CMsvSession* session = CMsvSession::OpenSyncL(*this); + CleanupStack::PushL(session); + + CMsvEntry* context = session->GetEntryL(KMsvRootIndexEntryId); + CleanupStack::PushL(context); + + iMsgStoreWalkFile.Write(_L8("id service_id related_id type mtm date size error biotype mtmdata1 mtmdata2 mtmdata3 description details\r\n\r\n")); + + // write details about the root entry + DoWriteMessageEntryInfoL(context, iMsgStoreWalkFile, 0); + + // get and write info recursively + TInt level(1); + WriteMessageEntryInfoRecursiveL(session, context, iMsgStoreWalkFile, level); + + CleanupStack::PopAndDestroy(2); //session, context + + iMsgStoreWalkFile.Flush(); + iMsgStoreWalkFile.Close(); + + _LIT(KMessage, "Msg. store walk written to %S"); + TFileName noteMsg; + noteMsg.Format(KMessage, &allAppsPath); + + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote(); + note->SetTimeout(CAknNoteDialog::ENoTimeout); + note->ExecuteLD(noteMsg); + } + else + { + _LIT(KMessage, "Failed writing to %S"); + TFileName noteMsg; + noteMsg.Format(KMessage, &allAppsPath); + + CAknErrorNote* note = new(ELeave) CAknErrorNote(); + note->SetTimeout(CAknNoteDialog::ENoTimeout); + note->ExecuteLD(noteMsg); + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::WriteMessageEntryInfoRecursiveL(CMsvSession* aSession, CMsvEntry* aContext, RFile& aFile, TInt& aLevel) + { + CMsvEntrySelection* entrySelection = aContext->ChildrenL(); + CleanupStack::PushL(entrySelection); + + for (TInt i=0; iCount(); i++) + { + CMsvEntry* entry = aSession->GetEntryL((*entrySelection)[i]); + CleanupStack::PushL(entry); + + DoWriteMessageEntryInfoL(entry, aFile, aLevel); + + // recurse into children + if (entry->Count() > 0) + { + aLevel++; + WriteMessageEntryInfoRecursiveL(aSession, entry, aFile, aLevel); + aLevel--; + } + + CleanupStack::PopAndDestroy(); // entry + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::DoWriteMessageEntryInfoL(CMsvEntry* aContext, RFile& aFile, TInt aLevel) + { + TMsvEntry messageEntry = aContext->Entry(); + + for (TInt j=0; j desc; + desc.Copy(messageEntry.iDescription); + + TBuf8<256> details; + details.Copy(messageEntry.iDetails); + + _LIT8(KLine, "-> %d %d %d %d %d %Ld %d %d %d %d %d %d %S %S\r\n"); + TBuf8<1024> buf; + buf.Format(KLine, messageEntry.Id(), messageEntry.iServiceId, messageEntry.iRelatedId, messageEntry.iType.iUid, + messageEntry.iMtm.iUid, messageEntry.iDate.Int64(), messageEntry.iSize, messageEntry.iError, messageEntry.iBioType, + messageEntry.iMtmData1, messageEntry.iMtmData2, messageEntry.iMtmData3, &desc, &details); + + aFile.Write(buf); + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::HandleSessionEventL(TMsvSessionEvent /*aEvent*/, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/) + { + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::FileEditorL(TInt aType) + { + // just get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iFileEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TFileEntry fileEntry = iFileEntryList->At(currentItemIndex); + + // only valid for files + if (!fileEntry.iEntry.IsDir()) + { + TFileName fullPath = fileEntry.iPath; + fullPath.Append(fileEntry.iEntry.iName); + + iModel->FileListContainer()->SetNaviPaneTextL(fileEntry.iEntry.iName); + + TInt editorMode(0); + + if (aType == EFileBrowserCmdFileViewText) + editorMode = EFileEditorViewAsText; + else if (aType == EFileBrowserCmdFileViewHex) + editorMode = EFileEditorViewAsHex; + else if (aType == EFileBrowserCmdFileEditText) + editorMode = EFileEditorEditAsText; + else if (aType == EFileBrowserCmdFileEditHex) + editorMode = EFileEditorEditAsHex; + else + User::Panic(_L("Inv.Ed.Mode"), 843); + + // launch dialog + CFileBrowserFileEditorDlg* dlg = CFileBrowserFileEditorDlg::NewL(fullPath, editorMode); + dlg->RunDlgLD(); + + iModel->FileListContainer()->SetNaviPaneTextL(iCurrentPath); + + if (aType == EFileBrowserCmdFileEditText || aType == EFileBrowserCmdFileEditHex) + RefreshViewL(); + } + } + } + +// -------------------------------------------------------------------------------------------- + +TBool CFileBrowserFileUtils::DriveSnapShotPossible() + { + // check that E-drive is available + TBool EDriveIsOK(EFalse); + + for (TInt i=0; iCount(); i++) + { + TDriveEntry driveEntry = iDriveEntryList->At(i); + + if (driveEntry.iNumber == EDriveE) + { + if (driveEntry.iVolumeInfo.iDrive.iMediaAtt & KMediaAttLocked || driveEntry.iVolumeInfo.iDrive.iDriveAtt & KDriveAbsent) + EDriveIsOK = EFalse; + else + EDriveIsOK = ETrue; + } + } + + if (!EDriveIsOK) + return EFalse; + + // get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iDriveEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TDriveEntry driveEntry = iDriveEntryList->At(currentItemIndex); + + // drive snapshot not possible when E-drive is highlighted, since that's where we are copying + if (driveEntry.iNumber == EDriveE) + return EFalse; + else + return ETrue; + } + + return EFalse; + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::DriveSnapShotL() + { + if (iModel->Settings().iBypassPlatformSecurity) + { + // get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iDriveEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TDriveEntry driveEntry = iDriveEntryList->At(currentItemIndex); + + TChar sourceDriveLetter = driveEntry.iLetter; + TChar targetDriveLetter = 'E'; // hardcoded drive letter, could be better if would be queried from the user + + // append to the command array + AppendToCommandArrayL(EFileBrowserFileOpCommandDriveSnapShot, + new(ELeave)CCommandParamsDriveSnapShot(sourceDriveLetter, targetDriveLetter) + ); + + // execute the operation + StartExecutingCommandsL(_L("Copying")); + } + } + else + { + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(_L("Enable \"bypass platform security\" from the settings first")); + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::SetDrivePasswordL() + { + // get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iDriveEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TMediaPassword oldPassword; + TMediaPassword newPassword; + TFileName oldPassword16; + TFileName newPassword16; + + TDriveEntry driveEntry = iDriveEntryList->At(currentItemIndex); + + // query existing password if it already exists + if (driveEntry.iVolumeInfo.iDrive.iMediaAtt & KMediaAttHasPassword) + { + CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL(oldPassword16); + textQuery->SetPromptL(_L("Existing password:")); + + if (textQuery->ExecuteLD(R_GENERAL_TEXT_QUERY)) + { + ConvertCharsToPwd(oldPassword16, oldPassword); + } + else + { + return; + } + } + + // query new password + newPassword16.Copy(oldPassword16); + + CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL(newPassword16); + textQuery->SetPromptL(_L("New password:")); + + if (textQuery->ExecuteLD(R_GENERAL_TEXT_QUERY)) + { + ConvertCharsToPwd(newPassword16, newPassword); + + // set the password, does not actually lock the drive + TInt err = iFs.LockDrive(driveEntry.iNumber, oldPassword, newPassword, ETrue); + + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("Password set")); + } + else if (err == KErrNotSupported) + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Not supported for this drive")); + } + else + { + CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv()); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD( textResolver->ResolveErrorString(err, CTextResolver::ECtxNoCtxNoSeparator) ); + + CleanupStack::PopAndDestroy(); //textResolver + } + + RefreshViewL(); + } + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::UnlockDriveL() + { + // get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iDriveEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TDriveEntry driveEntry = iDriveEntryList->At(currentItemIndex); + + // check if the drive is locked + if (driveEntry.iVolumeInfo.iDrive.iMediaAtt & KMediaAttLocked) + { + TMediaPassword oldPassword; + TFileName oldPassword16; + + CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL(oldPassword16); + textQuery->SetPromptL(_L("Existing password:")); + + if (textQuery->ExecuteLD(R_GENERAL_TEXT_QUERY)) + { + ConvertCharsToPwd(oldPassword16, oldPassword); + + // unlock the drive + TInt err = iFs.UnlockDrive(driveEntry.iNumber, oldPassword, ETrue) == KErrNone; + + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("Drive unlocked")); + } + else if (err == KErrNotSupported) + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Not supported for this drive")); + } + else + { + CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv()); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD( textResolver->ResolveErrorString(err, CTextResolver::ECtxNoCtxNoSeparator) ); + + CleanupStack::PopAndDestroy(); //textResolver + } + + RefreshViewL(); + } + } + else + { + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(_L("This drive is not locked")); + } + + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::ClearDrivePasswordL() + { + // get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iDriveEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TDriveEntry driveEntry = iDriveEntryList->At(currentItemIndex); + + // check if the drive has a password + if (driveEntry.iVolumeInfo.iDrive.iMediaAtt & KMediaAttHasPassword) + { + TMediaPassword oldPassword; + TFileName oldPassword16; + + CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL(oldPassword16); + textQuery->SetPromptL(_L("Existing password:")); + + if (textQuery->ExecuteLD(R_GENERAL_TEXT_QUERY)) + { + ConvertCharsToPwd(oldPassword16, oldPassword); + + // clear the password from the drive + TInt err = iFs.ClearPassword(driveEntry.iNumber, oldPassword); + + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("Password cleared")); + } + else if (err == KErrNotSupported) + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Not supported for this drive")); + } + else + { + CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv()); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD( textResolver->ResolveErrorString(err, CTextResolver::ECtxNoCtxNoSeparator) ); + + CleanupStack::PopAndDestroy(); //textResolver + } + + RefreshViewL(); + } + } + else + { + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(_L("This drive has no password")); + } + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::EraseDrivePasswordL() + { + // get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iDriveEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TDriveEntry driveEntry = iDriveEntryList->At(currentItemIndex); + + // check if the drive has a password + if (driveEntry.iVolumeInfo.iDrive.iMediaAtt & KMediaAttHasPassword) + { + CAknQueryDialog* query = CAknQueryDialog::NewL(); + + if (query->ExecuteLD(R_GENERAL_CONFIRMATION_QUERY, _L("Are you sure? All data can be lost!"))) + { + // erase the password from the drive + TInt err(KErrNone); + err = iFs.ErasePassword(driveEntry.iNumber); + + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("Password erased")); + } + else if (err == KErrNotSupported) + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Not supported for this drive")); + } + else + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Cannot erase, you may have to format the drive first")); + } + + RefreshViewL(); + } + } + else + { + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(_L("This drive has no password")); + } + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::FormatDriveL(TBool aQuickFormat) + { + // get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iDriveEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TDriveEntry driveEntry = iDriveEntryList->At(currentItemIndex); + + CAknQueryDialog* query = CAknQueryDialog::NewL(); + + if (query->ExecuteLD(R_GENERAL_CONFIRMATION_QUERY, _L("Are you sure? All data will be lost!"))) + { + TInt err(KErrNone); + TInt formatCount(0); + + TBuf<10> driveRoot; + driveRoot.Append(driveEntry.iLetter); + driveRoot.Append(_L(":")); + + TUint formatMode(0); + if (aQuickFormat) + formatMode = ESpecialFormat|EQuickFormat; + else + formatMode = ESpecialFormat|EFullFormat; + + // set as system application to prevent getting shut down events + iModel->EikonEnv()->SetSystem(ETrue); + + // first close any open applications + CBaBackupSessionWrapper* BSWrapper = CBaBackupSessionWrapper::NewL(); + CleanupStack::PushL(BSWrapper); + + TBackupOperationAttributes atts(MBackupObserver::EReleaseLockNoAccess, MBackupOperationObserver::EStart); + BSWrapper->NotifyBackupOperationL(atts); + + CAsyncWaiter* waiter = CAsyncWaiter::NewLC(); + BSWrapper->CloseAll( MBackupObserver::EReleaseLockNoAccess, waiter->iStatus ); + waiter->StartAndWait(); + CleanupStack::PopAndDestroy(); //waiter + + // some delay to make sure all applications have been closed + User::After(1000000); + + // format the drive + RFormat format; + err = format.Open(iFs, driveRoot, formatMode, formatCount); + + // Forced format for locked card + if ( err == KErrLocked ) + { + // Erase password and try again + err = iFs.ErasePassword( driveEntry.iNumber ); + if ( !err ) + { + err = format.Open(iFs, driveRoot, formatMode, formatCount); + } + } + + if( err != KErrNone && err != KErrLocked ) + { + CAknQueryDialog* lockQuery = CAknQueryDialog::NewL(); + if ( lockQuery->ExecuteLD(R_GENERAL_CONFIRMATION_QUERY, _L("Memory card in use by other application. Proceed anyway?"))) + { + // If format could not be started, someone is still keeping + // files open on media. Let's try to dismount file system, then + // remount with own extension embedded and try again. + + TFullName fsName; + err = iFs.FileSystemName( fsName, driveEntry.iNumber ); + + if ( err == KErrNone && fsName.Length() > 0 ) + { + // Prevent SysAp shutting down applications + RProperty::Set( + KPSUidCoreApplicationUIs, + KCoreAppUIsMmcRemovedWithoutEject, + ECoreAppUIsEjectCommandUsed ); + + TRequestStatus stat; + iFs.NotifyDismount( driveEntry.iNumber, stat, EFsDismountForceDismount ); + User::WaitForRequest( stat ); + + // Unfortunately, at the moment we have to wait until clients have received + // notification about card dismount. Otherwise at least causes problems with + // theme selected from card. In future clients should use new notify-API. + User::After( KForcedFormatTimeout ); + + // Let's set priority higher than normally. This is done to decrease the chance + // that someone reopens files on memory card after mandatory file system + // remounting hence preventing formatting again. + TThreadPriority priority( RThread().Priority() ); + RThread().SetPriority( EPriorityAbsoluteHigh ); + + // Mount file system back... + err = iFs.MountFileSystem( fsName, driveEntry.iNumber ); + err = format.Open(iFs, driveRoot, formatMode, formatCount); + RThread().SetPriority( priority ); + } + } + } + + + if (err == KErrNone) + { + // needs to be implemented with active objects + // CAknProgressDialog* dlg = new(ELeave) CAknProgressDialog(formatCount, 1, 1, NULL); + // dlg->SetTone(CAknNoteDialog::ENoTone); + // dlg->ExecuteLD(R_FORMAT_PROGRESS_NOTE); + + while (formatCount && err == KErrNone) + { + err = format.Next(formatCount); + } + } + + format.Close(); + + // restart closed applications + TBackupOperationAttributes atts2(MBackupObserver::ETakeLock, MBackupOperationObserver::EEnd); + BSWrapper->NotifyBackupOperationL(atts2); + BSWrapper->RestartAll(); + CleanupStack::PopAndDestroy(); //BSWrapper + + // system status not needed anymore + iModel->EikonEnv()->SetSystem(EFalse); + + + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("Format succeeded")); + } + else if (err == KErrNotSupported) + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Not supported for this drive")); + } + else + { + CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv()); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD( textResolver->ResolveErrorString(err, CTextResolver::ECtxNoCtxNoSeparator) ); + + CleanupStack::PopAndDestroy(); //textResolver + } + + RefreshViewL(); + } + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::EraseMBRL() + { + #ifndef FILEBROWSER_LITE + if (iModel->Settings().iBypassPlatformSecurity) + { + // get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iDriveEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TDriveEntry driveEntry = iDriveEntryList->At(currentItemIndex); + + CAknQueryDialog* query = CAknQueryDialog::NewL(); + if (query->ExecuteLD(R_GENERAL_CONFIRMATION_QUERY, _L("Are you sure? Your media driver must support this!"))) + { + + CAknQueryDialog* query2 = CAknQueryDialog::NewL(); + if (query2->ExecuteLD(R_GENERAL_CONFIRMATION_QUERY, _L("Are you really sure you know what are you doing ?!?"))) + { + // warn if the selected drive is not detected as removable + TBool proceed(EFalse); + + if (driveEntry.iVolumeInfo.iDrive.iDriveAtt & KDriveAttRemovable) + { + proceed = ETrue; + } + else + { + CAknQueryDialog* query3 = CAknQueryDialog::NewL(); + if (query3->ExecuteLD(R_GENERAL_CONFIRMATION_QUERY, _L("Selected drive is not removable, really continue?"))) + proceed = ETrue; + else + proceed = EFalse; + } + + if (proceed) + { + TInt err(KErrNone); + + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(_L("Please wait, this may take 30 seconds")); + + // set as system application to prevent getting shut down events + iModel->EikonEnv()->SetSystem(ETrue); + + // first close any open applications + CBaBackupSessionWrapper* BSWrapper = CBaBackupSessionWrapper::NewL(); + CleanupStack::PushL(BSWrapper); + + TBackupOperationAttributes atts(MBackupObserver::EReleaseLockNoAccess, MBackupOperationObserver::EStart); + BSWrapper->NotifyBackupOperationL(atts); + + CAsyncWaiter* waiter = CAsyncWaiter::NewLC(); + BSWrapper->CloseAll( MBackupObserver::EReleaseLockNoAccess, waiter->iStatus ); + waiter->StartAndWait(); + CleanupStack::PopAndDestroy(); //waiter + + // some delay to make sure all applications have been closed + User::After(1000000); + + + // do the erase MBR operation + err = iFileOps->EraseMBR(driveEntry.iNumber); + + + // restart closed applications + TBackupOperationAttributes atts2(MBackupObserver::ETakeLock, MBackupOperationObserver::EEnd); + BSWrapper->NotifyBackupOperationL(atts2); + BSWrapper->RestartAll(); + CleanupStack::PopAndDestroy(); //BSWrapper + + // system status not needed anymore + iModel->EikonEnv()->SetSystem(EFalse); + + + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("Erase MBR succeeded")); + } + else if (err == KErrNotSupported) + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Not supported for this drive")); + } + else + { + CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv()); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD( textResolver->ResolveErrorString(err, CTextResolver::ECtxNoCtxNoSeparator) ); + + CleanupStack::PopAndDestroy(); //textResolver + } + + RefreshViewL(); + } + } + } + } + } + else + { + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(_L("Enable \"bypass platform security\" from the settings first")); + } + #else + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(_L("Not supported in lite version")); + #endif + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::PartitionDriveL() + { + #ifndef FILEBROWSER_LITE + if (iModel->Settings().iBypassPlatformSecurity) + { + // get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iDriveEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TDriveEntry driveEntry = iDriveEntryList->At(currentItemIndex); + + CAknQueryDialog* query = CAknQueryDialog::NewL(); + if (query->ExecuteLD(R_GENERAL_CONFIRMATION_QUERY, _L("Are you sure? Your media driver must support this!"))) + { + + CAknQueryDialog* query2 = CAknQueryDialog::NewL(); + if (query2->ExecuteLD(R_GENERAL_CONFIRMATION_QUERY, _L("Are you really sure you know what are you doing ?!?"))) + { + // warn if the selected drive is not detected as removable + TBool proceed(EFalse); + + if (driveEntry.iVolumeInfo.iDrive.iDriveAtt & KDriveAttRemovable) + { + proceed = ETrue; + } + else + { + CAknQueryDialog* query3 = CAknQueryDialog::NewL(); + if (query3->ExecuteLD(R_GENERAL_CONFIRMATION_QUERY, _L("Selected drive is not removable, really continue?"))) + proceed = ETrue; + else + proceed = EFalse; + } + + if (proceed) + { + // query if erase mbr + TBool eraseMBR(EFalse); + + CAknQueryDialog* query4 = CAknQueryDialog::NewL(); + if (query4->ExecuteLD(R_GENERAL_CONFIRMATION_QUERY, _L("Erase MBR first (normally needed)?"))) + { + eraseMBR = ETrue; + } + + + // query amount of partitions from user + TInt queryIndex(0); + CAknListQueryDialog* listQueryDlg = new(ELeave) CAknListQueryDialog(&queryIndex); + + if (listQueryDlg->ExecuteLD(R_PARTITION_AMOUNT_QUERY)) + { + TInt amountOfPartitions = queryIndex + 1; // selections are 1..4 + + TInt err(KErrNone); + + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(_L("Please wait, this may take 30 seconds")); + + // set as system application to prevent getting shut down events + iModel->EikonEnv()->SetSystem(ETrue); + + // first close any open applications + CBaBackupSessionWrapper* BSWrapper = CBaBackupSessionWrapper::NewL(); + CleanupStack::PushL(BSWrapper); + + TBackupOperationAttributes atts(MBackupObserver::EReleaseLockNoAccess, MBackupOperationObserver::EStart); + BSWrapper->NotifyBackupOperationL(atts); + + CAsyncWaiter* waiter = CAsyncWaiter::NewLC(); + BSWrapper->CloseAll( MBackupObserver::EReleaseLockNoAccess, waiter->iStatus ); + waiter->StartAndWait(); + CleanupStack::PopAndDestroy(); //waiter + + // some delay to make sure all applications have been closed + User::After(1000000); + + // do the erase operation + if (eraseMBR) + { + err = iFileOps->EraseMBR(driveEntry.iNumber); + + if (err != KErrNone) + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Erase MBR failed")); + } + + User::After(500000); + } + + + // do the partition operation + err = iFileOps->PartitionDrive(driveEntry.iNumber, amountOfPartitions); + + + // restart closed applications + TBackupOperationAttributes atts2(MBackupObserver::ETakeLock, MBackupOperationObserver::EEnd); + BSWrapper->NotifyBackupOperationL(atts2); + BSWrapper->RestartAll(); + CleanupStack::PopAndDestroy(); //BSWrapper + + // system status not needed anymore + iModel->EikonEnv()->SetSystem(EFalse); + + + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("Partition succeeded")); + } + else if (err == KErrNotSupported) + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Not supported for this drive")); + } + else + { + CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv()); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD( textResolver->ResolveErrorString(err, CTextResolver::ECtxNoCtxNoSeparator) ); + + CleanupStack::PopAndDestroy(); //textResolver + } + + RefreshViewL(); + } + } + } + } + } + } + else + { + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(_L("Enable \"bypass platform security\" from the settings first")); + } + #else + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(_L("Not supported in lite version")); + #endif + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::CheckDiskL() + { + // get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iDriveEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TDriveEntry driveEntry = iDriveEntryList->At(currentItemIndex); + + TBuf<10> driveRoot; + driveRoot.Append(driveEntry.iLetter); + driveRoot.Append(_L(":")); + + // check disk + TInt err = iFs.CheckDisk(driveRoot); + + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("Integrity of the disk is ok")); + } + else if (err == KErrNotReady) + { + CAknInformationNote* note = new(ELeave) CAknInformationNote; + note->ExecuteLD(_L("Disk is empty")); + } + else if (err == KErrNotSupported) + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Not supported for this drive")); + } + else + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Disk is corrupted")); + } + + RefreshViewL(); + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::ScanDriveL() + { + // get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iDriveEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + CAknQueryDialog* query = CAknQueryDialog::NewL(); + + if (query->ExecuteLD(R_GENERAL_CONFIRMATION_QUERY, _L("This finds errors on disk and corrects them. Proceed?"))) + { + TDriveEntry driveEntry = iDriveEntryList->At(currentItemIndex); + + TBuf<10> driveRoot; + driveRoot.Append(driveEntry.iLetter); + driveRoot.Append(_L(":")); + + // scan disk + TInt err = iFs.ScanDrive(driveRoot); + + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("Run succesfully")); + } + else if (err == KErrNotSupported) + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Not supported for this drive")); + } + else + { + CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv()); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD( textResolver->ResolveErrorString(err, CTextResolver::ECtxNoCtxNoSeparator) ); + + CleanupStack::PopAndDestroy(); //textResolver + } + + RefreshViewL(); + } + } + } + + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::SetDriveNameL() + { + // get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iDriveEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TDriveEntry driveEntry = iDriveEntryList->At(currentItemIndex); + + TFileName driveName; + + // get existing drive name + iFs.GetDriveName(driveEntry.iNumber, driveName); + + CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL(driveName); + textQuery->SetPromptL(_L("New name:")); + + if (textQuery->ExecuteLD(R_GENERAL_TEXT_QUERY)) + { + // set drive name + TInt err = iFs.SetDriveName(driveEntry.iNumber, driveName); + + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("Name changed")); + } + else if (err == KErrNotSupported) + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Not supported for this drive")); + } + else + { + CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv()); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD( textResolver->ResolveErrorString(err, CTextResolver::ECtxNoCtxNoSeparator) ); + + CleanupStack::PopAndDestroy(); //textResolver + } + + RefreshViewL(); + } + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::SetDriveVolumeLabelL() + { + // get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iDriveEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TDriveEntry driveEntry = iDriveEntryList->At(currentItemIndex); + + // get existing volume label + TFileName volumeLabel; + volumeLabel.Copy(driveEntry.iVolumeInfo.iName); + + CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL(volumeLabel); + textQuery->SetPromptL(_L("New volume label:")); + + if (textQuery->ExecuteLD(R_GENERAL_TEXT_QUERY)) + { + // set volume label + TInt err = iFs.SetVolumeLabel(volumeLabel, driveEntry.iNumber); + + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("Volume label changed")); + } + else if (err == KErrNotSupported) + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Not supported for this drive")); + } + else + { + CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv()); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD( textResolver->ResolveErrorString(err, CTextResolver::ECtxNoCtxNoSeparator) ); + + CleanupStack::PopAndDestroy(); //textResolver + } + + RefreshViewL(); + } + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::EjectDriveL() + { + // get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iDriveEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TDriveEntry driveEntry = iDriveEntryList->At(currentItemIndex); + + TInt err(KErrNone); + + // get current filesystem name + TFileName fileSystemName; + err = iFs.FileSystemName(fileSystemName, driveEntry.iNumber); + + if (err == KErrNone) + { + // Prevent SysAp shutting down applications + RProperty::Set( + KPSUidCoreApplicationUIs, + KCoreAppUIsMmcRemovedWithoutEject, + ECoreAppUIsEjectCommandUsed ); + + // dismount the file system + err = iFs.DismountFileSystem(fileSystemName, driveEntry.iNumber); + + if (err == KErrNone) + { + // remount the file system + err = iFs.MountFileSystem(fileSystemName, driveEntry.iNumber); + + if (err == KErrInUse) + { + // try to remount after a while if locked + User::After(1000000); + err = iFs.MountFileSystem(fileSystemName, driveEntry.iNumber); + } + } + } + + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("Ejected succesfully")); + } + else if (err == KErrNotSupported) + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Not supported for this drive")); + } + else + { + CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv()); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD( textResolver->ResolveErrorString(err, CTextResolver::ECtxNoCtxNoSeparator) ); + + CleanupStack::PopAndDestroy(); //textResolver + } + + RefreshViewL(); + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::DismountFileSystemL() + { + // get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iDriveEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + CAknQueryDialog* query = CAknQueryDialog::NewL(); + + if (query->ExecuteLD(R_GENERAL_CONFIRMATION_QUERY, _L("Are you sure you know what are you doing?"))) + { + TDriveEntry driveEntry = iDriveEntryList->At(currentItemIndex); + + TInt err(KErrNone); + + // get current filesystem name + TFileName fileSystemName; + err = iFs.FileSystemName(fileSystemName, driveEntry.iNumber); + + if (err == KErrNone) + { + // Prevent SysAp shutting down applications + RProperty::Set( + KPSUidCoreApplicationUIs, + KCoreAppUIsMmcRemovedWithoutEject, + ECoreAppUIsEjectCommandUsed ); + + // dismount the file system + err = iFs.DismountFileSystem(fileSystemName, driveEntry.iNumber); + } + + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("Dismounted succesfully")); + } + else if (err == KErrNotSupported) + { + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD(_L("Not supported for this drive")); + } + else + { + CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv()); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD( textResolver->ResolveErrorString(err, CTextResolver::ECtxNoCtxNoSeparator) ); + + CleanupStack::PopAndDestroy(); //textResolver + } + + RefreshViewL(); + } + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::ConvertCharsToPwd(TDesC& aWord, TDes8& aConverted) const + { + aConverted.FillZ(aConverted.MaxLength()); + aConverted.Zero(); + + if (aWord.Length()) + { + aConverted.Copy( (TUint8*)(&aWord[0]), aWord.Size() ); + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::EditDataTypesL() + { + iModel->FileListContainer()->SetScreenLayoutL(EDisplayModeNormal); + iModel->FileListContainer()->SetNaviPaneTextL(KNullDesC); + + CFileBrowserDataTypesDlg* dlg = CFileBrowserDataTypesDlg::NewL(); + dlg->RunQueryLD(); + + iModel->FileListContainer()->SetScreenLayoutL(iModel->Settings().iDisplayMode); + iModel->FileListContainer()->SetNaviPaneTextL(iCurrentPath); + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::SecureBackupL(TInt aType) + { + TInt err(KErrNone); + TInt showStatus(EFalse); + + if (aType == EFileBrowserCmdToolsSecureBackupStartBackup || aType == EFileBrowserCmdToolsSecureBackupStartRestore) + { + TInt queryIndexState(0); + TInt queryIndexType(0); + + CAknListQueryDialog* listQueryDlgState = new(ELeave) CAknListQueryDialog(&queryIndexState); + if (listQueryDlgState->ExecuteLD(R_SECUREBACKUP_STATE_QUERY)) + { + + CAknListQueryDialog* listQueryDlgType = new(ELeave) CAknListQueryDialog(&queryIndexType); + if (listQueryDlgType->ExecuteLD(R_SECUREBACKUP_TYPE_QUERY)) + { + conn::TBURPartType partType = conn::EBURNormal; + conn::TBackupIncType backupIncType = conn::ENoBackup; + + if (aType == EFileBrowserCmdToolsSecureBackupStartBackup) + { + if (queryIndexState == ESecureBackupStateFull) + partType = conn::EBURBackupFull; + else if (queryIndexState == ESecureBackupStatePartial) + partType = conn::EBURBackupPartial; + } + else if (aType == EFileBrowserCmdToolsSecureBackupStartRestore) + { + if (queryIndexState == ESecureBackupStateFull) + partType = conn::EBURRestoreFull; + else if (queryIndexState == ESecureBackupStatePartial) + partType = conn::EBURRestorePartial; + } + + if (queryIndexType == ESecureBackupTypeBase) + backupIncType = conn::EBackupBase; + else if (queryIndexType == ESecureBackupTypeIncremental) + backupIncType = conn::EBackupIncrement; + + // start secure backup + err = iFileOps->ActivateSecureBackUp(partType, backupIncType); + showStatus = ETrue; + } + } + } + + else if (aType == EFileBrowserCmdToolsSecureBackupStop) + { + err = iFileOps->DeActivateSecureBackUp(); + showStatus = ETrue; + } + + else + User::Panic(_L("Sec.br.mode"), 101); + + + if (showStatus) + { + if (err == KErrNone) + { + CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote; + note->ExecuteLD(_L("Succeeded")); + } + else + { + CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv()); + + CAknErrorNote* note = new(ELeave) CAknErrorNote; + note->ExecuteLD( textResolver->ResolveErrorString(err, CTextResolver::ECtxNoCtxNoSeparator) ); + + CleanupStack::PopAndDestroy(); //textResolver + } + } + } + +// -------------------------------------------------------------------------------------------- + +void CFileBrowserFileUtils::OpenCommonFileActionQueryL() + { + // just get current item + TInt currentItemIndex = iModel->FileListContainer()->CurrentListBoxItemIndex(); + + if (iFileEntryList->Count() > currentItemIndex && currentItemIndex >= 0) + { + TInt queryIndex(0); + + CAknListQueryDialog* listQueryDlg = new(ELeave) CAknListQueryDialog(&queryIndex); + + if (listQueryDlg->ExecuteLD(R_COMMON_FILE_ACTION_QUERY)) + { + if (queryIndex == ECommonFileActionViewAsTextHex) + { + TFileEntry fileEntry = iFileEntryList->At(currentItemIndex); + + TFileName fullPath = fileEntry.iPath; + fullPath.Append(fileEntry.iEntry.iName); + + TInt viewerType(EFileBrowserCmdFileViewHex); + + // check from mime type if it's text + TDataType dataType; + TUid appUid; + if (iModel->LsSession().AppForDocument(fullPath, appUid, dataType) == KErrNone) + { + TBuf<128> mimeTypeBuf; + mimeTypeBuf.Copy(dataType.Des8()); + if (mimeTypeBuf == KNullDesC) + mimeTypeBuf.Copy(_L("N/A")); + + if (mimeTypeBuf.CompareF(_L("text/plain")) == 0) + viewerType = EFileBrowserCmdFileViewText; + } + + FileEditorL(viewerType); + } + + else if (queryIndex == ECommonFileActionOpenWithApparc) + { + OpenWithApparcL(); + } + + else if (queryIndex == ECommonFileActionOpenWithDocHandlerEmbed) + { + OpenWithDocHandlerL(ETrue); + } + + else + User::Panic(_L("Unk.Com.Act"), 221); + + } + } + } + +// -------------------------------------------------------------------------------------------- + +// End of File