1 /*

     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 #include "FBFileUtils.h"

    20 #include "FBFileOps.h"

    21 #include "engine.h"

    22 #include "FB.hrh"

    23 #include <filebrowser.rsg>

    24 

    25 #include <textresolver.h> 

    26 #include <eikprogi.h>

    27 #include <e32svr.h>

    28 #include <eikfutil.h>

    29 #include <apparc.h>

    30 #include <apaid.h>

    31 #include <apaidpartner.h>

    32 #include <eikenv.h>

    33 #include <bautils.h>

    34 #include <gulicon.h>

    35 #include <babackup.h> 

    36 //#include <aknmemorycardui.mbg>

    37 #include <sendui.h>

    38 #include <CMessageData.h>

    39 #include <ezgzip.h>

    40 #include <e32hal.h>

    41 #include <pathinfo.h>

    42 #include <apgcli.h>

    43 #include <apmstd.h>

    44 #include <apgtask.h>

    45 #include <apacmdln.h>

    46 #include <DocumentHandler.h>

    47 #include <msvapi.h>

    48 #include <msvids.h>

    49 #include <msvstd.h>

    50 #include <msvstore.h>

    51 #include <mmsvattachmentmanager.h>

    52 #include <cmsvattachment.h>

    53 #include <hash.h>

    54 //#include <sbeclient.h>

    55 #include <e32property.h>

    56 #if (!defined __SERIES60_30__ && !defined __SERIES60_31__) 

    57 #include <driveinfo.h>

    58 #endif // !defined __SERIES60_30__ && !defined __SERIES60_31__

    59 

    60 #ifndef __SERIES60_30__

    61 //  #include <akniconconfig.h>

    62 #endif

    63 

    64 //_LIT(KGZipExt, ".gz");

    65 _LIT8(KFileNewLine, "\r\n");

    66 const TInt KForcedFormatTimeout = 1000000;

    67 

    68 // copied from coreapplicationuisdomainpskeys.h

    69 const TUid KPSUidCoreApplicationUIs = { 0x101F8767 };

    70 const TUint32 KCoreAppUIsMmcRemovedWithoutEject = 0x00000109;

    71 enum TCoreAppUIsMmcRemovedWithoutEject

    72     {

    73     ECoreAppUIsEjectCommandUsedUninitialized = 0,

    74     ECoreAppUIsEjectCommandNotUsed,

    75     ECoreAppUIsEjectCommandUsed,

    76     ECoreAppUIsEjectCommandUsedToDrive // Low 16-bits contain this value and high 16-bits TDriveNumber to eject

    77     };

    78 const TInt KDriveLetterStringLength = 3; // e.g. C:\

    79 

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

    81 

    82 CFileBrowserFileUtils* CFileBrowserFileUtils::NewL(CEngine* aEngine)

    83 	{

    84 	CFileBrowserFileUtils* self = new(ELeave) CFileBrowserFileUtils(aEngine);

    85 	CleanupStack::PushL(self);

    86 	self->ConstructL();

    87 	CleanupStack::Pop();

    88 	return self;

    89 	}

    90 

    91 // --------------------------------------------------------------------------------------------

    92 

    93 CFileBrowserFileUtils::CFileBrowserFileUtils(CEngine* aEngine) : CActive(EPriorityStandard), iEngine(aEngine)

    94 	{

    95 	}

    96 

    97 // --------------------------------------------------------------------------------------------

    98 

    99 void CFileBrowserFileUtils::ConstructL()

   100 	{

   101     User::LeaveIfError(iTimer.CreateLocal());

   102     User::LeaveIfError(iFs.Connect());

   103     User::LeaveIfError(iTz.Connect());

   104     

   105     iState = EIdle;

   106     iListingMode = ENormalEntries;

   107 

   108     iSortMode = EFileBrowserCmdViewSortByName;

   109     iOrderMode = EFileBrowserCmdViewOrderAscending;

   110     iCurrentPath = KNullDesC;

   111     

   112     iFileOps = CFileBrowserFileOps::NewL(iEngine);

   113     

   114     iDriveEntryList = new(ELeave) CDriveEntryList(8);

   115     iFileEntryList = new(ELeave) CFileEntryList(64);

   116     iFindFileEntryList = new(ELeave) CFileEntryList(64);

   117     iAppIconList = new(ELeave) CAppIconList(16);

   118     iClipBoardList = new(ELeave) CFileEntryList(64);

   119     iCurrentSelectionList = new(ELeave) CFileEntryList(64);

   120 

   121     iDocHandler = CDocumentHandler::NewL();

   122 //    iDocHandler->SetExitObserver(this);

   123     

   124     // set defaults to the search settings

   125     iSearchAttributes.iSearchDir = KNullDesC;

   126     iSearchAttributes.iWildCards = _L("*.jpg");

   127     iSearchAttributes.iTextInFile = KNullDesC;

   128     iSearchAttributes.iMinSize = 0;

   129     iSearchAttributes.iMaxSize = 999999999;

   130     iSearchAttributes.iMinDate = TDateTime(1980, EJanuary,   0,0,0,0,0);

   131     iSearchAttributes.iMaxDate = TDateTime(2060, EDecember, 30,0,0,0,0);

   132     iSearchAttributes.iRecurse = ETrue;

   133     

   134     // init the command array

   135     iCommandArray = new(ELeave) CCommandArray(64);

   136         

   137     // get current path from settings

   138     if (iEngine->Settings().iRememberLastPath)

   139         {

   140         TFileName settingPath = iEngine->Settings().iLastPath;

   141         if (BaflUtils::PathExists(iFs, settingPath))

   142             iCurrentPath = settingPath;

   143         

   144         if (iCurrentPath != KNullDesC)

   145             GetDriveListL();

   146         }

   147 

   148     CActiveScheduler::Add(this);

   149     }

   150 

   151 // --------------------------------------------------------------------------------------------

   152 

   153 CFileBrowserFileUtils::~CFileBrowserFileUtils()

   154 	{

   155 	Cancel();

   156 	

   157 	// save current path from settings

   158     if (iEngine->Settings().iRememberLastPath)

   159         {

   160         iEngine->Settings().iLastPath = iCurrentPath;

   161         TRAP_IGNORE(iEngine->SaveSettingsL(EFalse));

   162         }

   163 

   164 //    if (iWaitDialog)

   165 //        TRAP_IGNORE(iWaitDialog->ProcessFinishedL()); 

   166 //     

   167 //    if (iProgressDialog)

   168 //        TRAP_IGNORE(iProgressDialog->ProcessFinishedL());

   169     

   170         delete iFileOps;

   171 

   172         delete iDocHandler;

   173 	

   174 //	if (iOpenFileService)

   175 //	    delete iOpenFileService;

   176 	

   177         delete iCurrentSelectionList;

   178         delete iClipBoardList;

   179         delete iAppIconList;

   180         delete iFindFileEntryList;

   181         delete iFileEntryList;

   182         delete iDriveEntryList;

   183 

   184         delete iFileMan;

   185 

   186         if (iCommandArray)

   187             {

   188             ResetCommandArray();

   189             delete iCommandArray;

   190             }

   191 

   192         iTz.Close();

   193         iFs.Close();

   194         iTimer.Close();

   195         }

   196 

   197 // --------------------------------------------------------------------------------------------

   198 

   199 void CFileBrowserFileUtils::DoCancel()

   200 	{

   201     iTimer.Cancel();

   202 	}

   203 

   204 // --------------------------------------------------------------------------------------------

   205 

   206 void CFileBrowserFileUtils::StartExecutingCommandsL(const TDesC& aLabel)

   207     {

   208     if (iCommandArray->Count() >= 2)

   209         {

   210         // init progress bar

   211 //        iProgressDialog = new(ELeave) CAknProgressDialog((reinterpret_cast<CEikDialog**>(&iProgressDialog)), ETrue);

   212 //        iProgressDialog->SetCallback(this);

   213 //        iProgressDialog->PrepareLC(R_GENERAL_PROGRESS_NOTE);

   214 //        iProgressDialog->SetCurrentLabelL( EAknCtNote, aLabel );

   215 //        iProgressInfo = iProgressDialog->GetProgressInfoL();

   216 //        iProgressInfo->SetFinalValue( CommandArrayCount() );

   217 //        iProgressDialog->RunLD();

   218 //        iProgressDialog->MakeVisible( ETrue );        

   219         iEngine->FileBrowserUI()->ShowProgressDialog(aLabel, 0, CommandArrayCount());

   220         isProgressDialog = ETrue;

   221         }

   222     else if (iCommandArray->Count() >= 1)

   223         {

   224         // init wait dialog

   225 //        iWaitDialog = new(ELeave) CAknWaitDialog((reinterpret_cast<CEikDialog**>(&iWaitDialog)), ETrue);

   226 //        iWaitDialog->SetCallback(this);

   227 //        iWaitDialog->PrepareLC(R_GENERAL_WAIT_NOTE);

   228 //        iWaitDialog->SetTextL( aLabel );

   229 //        iWaitDialog->RunLD();

   230         iEngine->FileBrowserUI()->ShowWaitDialog(aLabel);

   231         isWaitDialog = ETrue;

   232         }

   233     else

   234         {

   235         // no commands, just do nothing

   236         return;

   237         }

   238 

   239 

   240     // start with the first operation

   241     iCurrentEntry = 0;

   242     iSucceededOperations = 0;

   243     iFailedOperations = 0;

   244 

   245     // starts executing commands

   246     ExecuteCommand();

   247     }

   248     

   249 // --------------------------------------------------------------------------------------------

   250 

   251 void CFileBrowserFileUtils::ExecuteCommand()

   252     {

   253     // make sure the engine isn't active, should never happen

   254     __ASSERT_ALWAYS(!IsActive(), User::Panic(_L("FileUtils:IsActive"), 333));

   255 

   256     // execute a command after a very short delay (25ms)

   257     if (isWaitDialog)

   258         {

   259         iEngine->FileBrowserUI()->ProcessEvents();

   260         }

   261     if (isProgressDialog)

   262         {

   263         TInt newValue = iCurrentEntry;

   264         iEngine->FileBrowserUI()->SetProgressValue(newValue);

   265         }

   266     iTimer.After(iStatus, 25);

   267     SetActive();

   268     }

   269 

   270 // --------------------------------------------------------------------------------------------

   271     

   272 void CFileBrowserFileUtils::RunL()

   273     {

   274     TInt err(KErrNone);

   275     TInt currentCommand = iCommandArray->At(iCurrentEntry).iCommandId;

   276 

   277     // execute a command from the queue

   278     switch(currentCommand)

   279         {

   280         case EFileBrowserFileOpCommandAttribs:

   281             {

   282             CCommandParamsAttribs* params = static_cast<CCommandParamsAttribs*>(iCommandArray->At(iCurrentEntry).iParameters);

   283             err = iFileOps->Attribs(params->iSourceEntry, params->iSetMask, params->iClearMask, params->iTime, params->iSwitch);

   284             }

   285             break;

   286             

   287         case EFileBrowserFileOpCommandCopy:

   288             {

   289             CCommandParamsCopyOrMove* params = static_cast<CCommandParamsCopyOrMove*>(iCommandArray->At(iCurrentEntry).iParameters);

   290             err = iFileOps->Copy(params->iSourceEntry, params->iTargetPath, params->iSwitch);

   291             }

   292             break;

   293             

   294         case EFileBrowserFileOpCommandMove:

   295             {

   296             CCommandParamsCopyOrMove* params = static_cast<CCommandParamsCopyOrMove*>(iCommandArray->At(iCurrentEntry).iParameters);

   297             err = iFileOps->Copy(params->iSourceEntry, params->iTargetPath, params->iSwitch, ETrue);

   298             }

   299             break;

   300                 

   301         case EFileBrowserFileOpCommandRename:

   302             {

   303             CCommandParamsRename* params = static_cast<CCommandParamsRename*>(iCommandArray->At(iCurrentEntry).iParameters);

   304             err = iFileOps->Rename(params->iSourceEntry, params->iTargetPath, params->iSwitch);

   305             }

   306             break;

   307 

   308         case EFileBrowserFileOpCommandDelete:

   309             {

   310             CCommandParamsDelete* params = static_cast<CCommandParamsDelete*>(iCommandArray->At(iCurrentEntry).iParameters);

   311             err = iFileOps->Delete(params->iSourceEntry, params->iSwitch);

   312             }

   313             break;

   314 

   315         case EFileBrowserFileOpCommandDriveSnapShot:

   316             {

   317             CCommandParamsDriveSnapShot* params = static_cast<CCommandParamsDriveSnapShot*>(iCommandArray->At(iCurrentEntry).iParameters);

   318             err = iFileOps->DriveSnapShot(params->iSourceDriveLetter, params->iTargetDriveLetter);

   319             }

   320             break;

   321                                                 

   322         default:

   323             User::Panic (_L("Unknown command"), 400);

   324             break;

   325         }

   326 

   327     

   328     if (err == KErrNone)

   329         {

   330         iSucceededOperations++;

   331         }

   332     else if ( err != KErrCancel )

   333         {

   334         iFailedOperations++;

   335         }

   336         

   337     iLastError = err;            

   338 

   339     // check for more commands in queue

   340     TRAP_IGNORE( CheckForMoreCommandsL() );

   341     }

   342 

   343 // ---------------------------------------------------------------------------

   344 

   345 TInt CFileBrowserFileUtils::RunError(TInt aError)

   346     {

   347     _LIT(KMessage, "Command error %d");

   348     TBuf<128> noteMsg;

   349     noteMsg.Format(KMessage, aError);

   350             

   351     iEngine->EikonEnv()->InfoMsg(noteMsg);

   352     

   353     TRAP_IGNORE( CheckForMoreCommandsL() );

   354     

   355     return KErrNone;

   356     }

   357 

   358 // ---------------------------------------------------------------------------

   359 

   360 void CFileBrowserFileUtils::CheckForMoreCommandsL()

   361     {

   362     //LOGSTRING("Creator: CCreatorEngine::CheckForMoreCommandsL");

   363     

   364     // update the progress bar

   365 //    if (iProgressInfo)

   366 //        iProgressInfo->IncrementAndDraw(1);

   367 

   368 	// check if we have more commands to be executed

   369 	if (iCurrentEntry >= CommandArrayCount() - 1)

   370 		{

   371         //LOGSTRING("Creator: CCreatorEngine::CheckForMoreCommandsL all done");

   372 

   373         // all done, free resources

   374         ResetCommandArray();

   375         

   376         // deactive secure backup if it was activated by a file command

   377         iFileOps->DeActivateSecureBackUpViaFileOp();

   378 

   379         // dismiss any wait/progress dialogs        

   380         if (isWaitDialog)

   381             {

   382             iEngine->FileBrowserUI()->CancelWaitDialog();

   383             isWaitDialog = EFalse;

   384             }

   385         if (isProgressDialog)

   386             {

   387             iEngine->FileBrowserUI()->CancelProgressDialog();

   388             isProgressDialog = EFalse;

   389             }

   390 //        if (iWaitDialog)

   391 //            {

   392 //            TRAP_IGNORE(iWaitDialog->ProcessFinishedL()); 

   393 //            iWaitDialog = NULL;

   394 //            }

   395 //        if (iProgressDialog)

   396 //            {

   397 //            TRAP_IGNORE(iProgressDialog->ProcessFinishedL());

   398 //            iProgressDialog = NULL;

   399 //            }

   400 

   401 

   402         // show result note

   403         if ( iSucceededOperations == 0 && iFailedOperations == 0 )

   404             {

   405             // single operation cancelled -> show nothing

   406             }

   407         else if (iSucceededOperations == 1 && iFailedOperations == 0)    

   408             {

   409             _LIT(KMessage, "Operation succeeded");

   410             iEngine->FileBrowserUI()->ShowConfirmationNote(KMessage);

   411             }

   412         else if (iSucceededOperations > 0 && iFailedOperations == 0)    

   413             {

   414             _LIT(KMessage, "%d operations succeeded");

   415             TBuf<128> noteMsg;

   416             noteMsg.Format(KMessage, iSucceededOperations);

   417             iEngine->FileBrowserUI()->ShowConfirmationNote(noteMsg);

   418             }

   419         else if (iSucceededOperations == 0 && iFailedOperations > 1)    

   420             {

   421             _LIT(KMessage, "%d operations failed");

   422             TBuf<128> noteMsg;

   423             noteMsg.Format(KMessage, iFailedOperations);

   424 

   425             iEngine->FileBrowserUI()->ShowErrorNote(noteMsg);

   426             }

   427         else if (iSucceededOperations > 0 && iFailedOperations > 0)    

   428             {

   429             _LIT(KMessage, "%d operations succeeded, %d failed");

   430             TBuf<128> noteMsg;

   431             noteMsg.Format(KMessage, iSucceededOperations, iFailedOperations);

   432 

   433             iEngine->FileBrowserUI()->ShowInformationNote(noteMsg, _L(""));

   434             }

   435         else    

   436             {

   437             CTextResolver* textResolver = CTextResolver::NewLC(*iEngine->EikonEnv());

   438 

   439             iEngine->FileBrowserUI()->ShowErrorNote(

   440                     textResolver->ResolveErrorString(iLastError, CTextResolver::ECtxNoCtxNoSeparator) );

   441 

   442             CleanupStack::PopAndDestroy();  //textResolver

   443             }

   444 

   445         RefreshViewL();

   446         iEngine->FileBrowserUI()->NotifyModelHasChanged();

   447 

   448             }

   449 	else

   450             {

   451             // maintain requests

   452             iCurrentEntry++;

   453 

   454             //LOGSTRING2("Creator: CCreatorEngine::CheckForMoreCommandsL iCurrentEntry=%d", iCurrentEntry);

   455 

   456             ExecuteCommand();

   457             }

   458     }    

   459 // --------------------------------------------------------------------------------------------

   460 

   461 // This callback function is called when cancel button of the progress bar was pressed

   462 void CFileBrowserFileUtils::DialogDismissedL(/*TInt aButtonId*/)

   463     {

   464 //    iProgressDialog = NULL;

   465 //    iProgressInfo = NULL;

   466 //    iWaitDialog = NULL;

   467     

   468     // check if cancel button was pressed

   469 //    if (aButtonId == EAknSoftkeyCancel)

   470 //        {

   471         // cancel the active object, command executer 

   472         Cancel();

   473         

   474         iFileOps->CancelOp();

   475         

   476         ResetCommandArray();

   477 

   478         isProgressDialog = EFalse;

   479 

   480         iEngine->FileBrowserUI()->ShowInformationNote(_L("Cancelled"), _L(""));

   481 //        }

   482     }

   483     

   484 // --------------------------------------------------------------------------------------------

   485 

   486 void CFileBrowserFileUtils::AppendToCommandArrayL(TInt aCommand, CCommandParamsBase* aParameters)

   487     {

   488     if (iCommandArray)

   489         iCommandArray->AppendL( TCommand(aCommand, aParameters) );

   490     else

   491         User::Leave(KErrNotReady);

   492     }

   493 

   494 // --------------------------------------------------------------------------------------------

   495 

   496 TInt CFileBrowserFileUtils::CommandArrayCount() const

   497     {

   498     TInt count(0);

   499     

   500     if (iCommandArray)

   501         count = iCommandArray->Count();

   502     

   503     return count;

   504     }

   505 

   506 // --------------------------------------------------------------------------------------------

   507 

   508 void CFileBrowserFileUtils::ResetCommandArray()

   509     {

   510     // delete params first

   511     for (TInt i=0; i<CommandArrayCount(); i++)

   512         {

   513         if ( iCommandArray->At(i).iParameters )

   514             {

   515             delete iCommandArray->At(i).iParameters;

   516             iCommandArray->At(i).iParameters = NULL;

   517             }

   518         }

   519 

   520     // reset the entries

   521     iCommandArray->Reset();

   522     }

   523                     

   524 // --------------------------------------------------------------------------------------------

   525 

   526 void CFileBrowserFileUtils::HandleSettingsChangeL()

   527     {

   528 	// TODO

   529 

   530 //    if (iEngine->FileListContainer())

   531 //        {

   532 //        iEngine->FileListContainer()->SetScreenLayoutL(iEngine->Settings().iDisplayMode);

   533 //        iEngine->FileListContainer()->CreateListBoxL(iEngine->Settings().iFileViewMode);

   534         //iEngine->FileListContainer()->SetNaviPaneTextL(iCurrentPath);

   535         RefreshViewL();

   536 //        }

   537     }

   538 

   539 // --------------------------------------------------------------------------------------------

   540 

   541 void CFileBrowserFileUtils::SetSortModeL(TInt aSortMode)

   542     {

   543     iSortMode = aSortMode;

   544     RefreshViewL();

   545     }

   546     

   547 // --------------------------------------------------------------------------------------------

   548 

   549 void CFileBrowserFileUtils::SetOrderModeL(TInt aOrderMode)

   550     {

   551     iOrderMode = aOrderMode;

   552     RefreshViewL();

   553     }

   554 

   555 // --------------------------------------------------------------------------------------------

   556 

   557 TKeyResponse CFileBrowserFileUtils::HandleOfferKeyEventL(const TKeyEvent& /*aKeyEvent*/, TEventCode /*aType*/)

   558     {

   559 	// TODO

   560 	/*

   561     if(aType != EEventKey)

   562         return EKeyWasNotConsumed;

   563     

   564     TBool shiftKeyPressed = (aKeyEvent.iModifiers & EModifierShift) ||

   565                             (aKeyEvent.iModifiers & EModifierLeftShift) ||

   566                             (aKeyEvent.iModifiers & EModifierRightShift);

   567     TBool controlKeyPressed = (aKeyEvent.iModifiers & EModifierCtrl) || 

   568                               (aKeyEvent.iModifiers & EModifierRightCtrl); 

   569     

   570     // handle left arrow key press

   571     if (aKeyEvent.iCode == EKeyLeftArrow)

   572         {

   573         MoveUpOneLevelL();

   574         return EKeyWasConsumed;

   575         }

   576     

   577     // handle right arrow key press

   578     else if (aKeyEvent.iCode == EKeyRightArrow)

   579         {

   580         if (IsDriveListViewActive() && iDriveEntryList->Count() > 0)

   581             {

   582             MoveDownToDirectoryL();

   583             return EKeyWasConsumed;

   584             }

   585         else if (iFileEntryList->Count() > 0)

   586             {

   587             MoveDownToDirectoryL();

   588             return EKeyWasConsumed;

   589             }        

   590         }    

   591 

   592     // skip OK/Enter keys when shift or ctrl is pressed because those are needed by the listbox

   593     else if ((aKeyEvent.iCode == EKeyOK || aKeyEvent.iCode == EKeyEnter) && (shiftKeyPressed || controlKeyPressed))

   594         {

   595         return EKeyWasNotConsumed;

   596         }

   597     

   598     // handle OK/Enter keys

   599     else if (aKeyEvent.iCode == EKeyOK || aKeyEvent.iCode == EKeyEnter)

   600         {

   601         if (IsDriveListViewActive() && iDriveEntryList->Count() > 0)

   602             {

   603             MoveDownToDirectoryL();

   604             return EKeyWasConsumed;

   605             }

   606         else if (iFileEntryList->Count() > 0)

   607             {

   608             TFileEntry fileEntry = iFileEntryList->At(iEngine->FileListContainer()->CurrentListBoxItemIndex());

   609             

   610             if (fileEntry.iEntry.IsDir())

   611                 MoveDownToDirectoryL();

   612             else

   613                 OpenCommonFileActionQueryL();

   614             

   615             return EKeyWasConsumed;

   616             } 

   617         }

   618     

   619     // handle Delete/Backspace keys

   620     else if (!iEngine->FileListContainer()->SearchField() && (aKeyEvent.iCode == EKeyBackspace || aKeyEvent.iCode == EKeyDelete) &&

   621              !iEngine->FileUtils()->IsCurrentDriveReadOnly() && !iEngine->FileUtils()->IsDriveListViewActive())

   622         {

   623         DeleteL();

   624         return EKeyWasConsumed;

   625         }

   626     */                      

   627     return EKeyWasNotConsumed;

   628     }        

   629 // --------------------------------------------------------------------------------------------

   630 

   631 void CFileBrowserFileUtils::RefreshViewL()

   632     {

   633 //    if (iEngine->FileListContainer())

   634 //        {

   635 //

   636 //        // make sure that the search field is disabled

   637 //        iEngine->FileListContainer()->DisableSearchFieldL();

   638         

   639         // read directory listing

   640         GenerateDirectoryDataL();

   641         

   642 //        // set an icon array

   643 //        iEngine->FileListContainer()->SetListBoxIconArrayL(GenerateIconArrayL());

   644 //

   645 //        // set text items

   646 //        iEngine->FileListContainer()->SetListBoxTextArrayL(GenerateItemTextArrayL());

   647 //        }

   648     }

   649     

   650 // --------------------------------------------------------------------------------------------

   651 

   652 //CAknIconArray* CFileBrowserFileUtils::GenerateIconArrayL(TBool aGenerateNewBasicIconArray)

   653 //    {

   654 //	// TODO

   655 //

   656 //    CAknIconArray* iconArray = NULL;

   657 //

   658 //    if (aGenerateNewBasicIconArray)

   659 //        {

   660 //        iconArray = new(ELeave) CAknIconArray(16);

   661 //        }

   662 //    else

   663 //        {

   664 //        if (iEngine->FileListContainer())

   665 //            iconArray = iEngine->FileListContainer()->ListBoxIconArrayL();

   666 //

   667 //        if (!iconArray)

   668 //            iconArray = new(ELeave) CAknIconArray(16);

   669 //        }

   670 //

   671 //

   672 //    CleanupStack::PushL(iconArray);

   673 //

   674 //    // generate basic items if not already existing

   675 //    if (iconArray->Count() < EFixedIconListLength)

   676 //        {

   677 //        // reset arrays

   678 //        iconArray->Reset();

   679 //        iAppIconList->Reset();

   680 //

   681 //        // get default control color

   682 //        TRgb defaultColor;

   683 //        defaultColor = iEngine->EikonEnv()->Color(EColorControlText);

   684 //

   685 //        // create a color icon of the marking indicator

   686 //        CFbsBitmap* markBitmap = NULL;

   687 //        CFbsBitmap* markBitmapMask = NULL;

   688 //

   689 //        AknsUtils::CreateColorIconL(AknsUtils::SkinInstance(),

   690 //                KAknsIIDQgnIndiMarkedAdd,

   691 //                KAknsIIDQsnIconColors,

   692 //                EAknsCIQsnIconColorsCG13,

   693 //                markBitmap,

   694 //                markBitmapMask,

   695 //                AknIconUtils::AvkonIconFileName(),

   696 //                EMbmAvkonQgn_indi_marked_add,

   697 //                EMbmAvkonQgn_indi_marked_add_mask,

   698 //                defaultColor

   699 //                );

   700 //

   701 //        // 0 marking indicator

   702 //        CGulIcon* markIcon = CGulIcon::NewL(markBitmap, markBitmapMask);

   703 //        iconArray->AppendL(markIcon);

   704 //

   705 //        // 1 empty

   706 //        AppendGulIconToIconArrayL(iconArray, AknIconUtils::AvkonIconFileName(),

   707 //                                  EMbmAvkonQgn_prop_empty, EMbmAvkonQgn_prop_empty_mask, KAknsIIDQgnPropEmpty);

   708 //        // 2 phone memory

   709 //        AppendGulIconToIconArrayL(iconArray, AknIconUtils::AvkonIconFileName(),

   710 //                                  EMbmAvkonQgn_prop_phone_memc, EMbmAvkonQgn_prop_phone_memc_mask, KAknsIIDQgnPropPhoneMemc);

   711 //        // 3 memory card

   712 //        AppendGulIconToIconArrayL(iconArray, KMemoryCardUiBitmapFile,

   713 //                                  EMbmAknmemorycarduiQgn_prop_mmc_memc, EMbmAknmemorycarduiQgn_prop_mmc_memc_mask, KAknsIIDQgnPropMmcMemc);

   714 //        // 4 memory card disabled

   715 //        AppendGulIconToIconArrayL(iconArray, KMemoryCardUiBitmapFile,

   716 //                                  EMbmAknmemorycarduiQgn_prop_mmc_non, EMbmAknmemorycarduiQgn_prop_mmc_non_mask, KAknsIIDQgnPropMmcNon);

   717 //        // 5 folder

   718 //        AppendGulIconToIconArrayL(iconArray, AknIconUtils::AvkonIconFileName(),

   719 //                                  EMbmAvkonQgn_prop_folder_small, EMbmAvkonQgn_prop_folder_small_mask, KAknsIIDQgnPropFolderSmall);

   720 //        // 6 folder with subfolders

   721 //        AppendGulIconToIconArrayL(iconArray, AknIconUtils::AvkonIconFileName(),

   722 //                                  EMbmAvkonQgn_prop_folder_sub_small, EMbmAvkonQgn_prop_folder_sub_small_mask, KAknsIIDQgnPropFolderSubSmall);

   723 //        // 7 current folder

   724 //        AppendGulIconToIconArrayL(iconArray, AknIconUtils::AvkonIconFileName(),

   725 //                                  EMbmAvkonQgn_prop_folder_current, EMbmAvkonQgn_prop_folder_current_mask, KAknsIIDQgnPropFolderCurrent);

   726 //        }

   727 //

   728 //    // append custom icons if not in drive list view and setting is enabled

   729 //    if (!aGenerateNewBasicIconArray && !IsDriveListViewActive() && iEngine->Settings().iShowAssociatedIcons)

   730 //        {

   731 //        // init id counter

   732 //        TInt idCounter(EFixedIconListLength + iAppIconList->Count());

   733 //

   734 //        // loop all items in the file list

   735 //        for (TInt i=0; i<iFileEntryList->Count(); i++)

   736 //            {

   737 //            TFileEntry& fileEntry = iFileEntryList->At(i);

   738 //

   739 //            // just check for normal files

   740 //            if (!fileEntry.iEntry.IsDir())

   741 //                {

   742 //                TUid appUid = GetAppUid(fileEntry);

   743 //                TInt iconId = AppIconIdForUid(appUid);

   744 //

   745 //                if (appUid != KNullUid && iconId == KErrNotFound)

   746 //                    {

   747 //                    // icon not found from the icon array, generate it

   748 //                    CFbsBitmap* bitmap = NULL;

   749 //                    CFbsBitmap* mask = NULL;

   750 //                    CGulIcon* appIcon = NULL;

   751 //

   752 //                    TRAPD(err,

   753 //                        AknsUtils::CreateAppIconLC(AknsUtils::SkinInstance(), appUid, EAknsAppIconTypeList, bitmap, mask);

   754 //                        appIcon = CGulIcon::NewL(bitmap, mask);

   755 //                        CleanupStack::Pop(2); //bitmap, mask

   756 //                        );

   757 //

   758 //                    if (err == KErrNone)

   759 //                        {

   760 //                        TAppIcon appIconEntry;

   761 //                        appIconEntry.iId = idCounter;

   762 //                        appIconEntry.iUid = appUid;

   763 //

   764 //                        appIcon->SetBitmapsOwnedExternally(EFalse);

   765 //                        iconArray->AppendL(appIcon);

   766 //                        iAppIconList->AppendL(appIconEntry);

   767 //

   768 //                        fileEntry.iIconId = idCounter;

   769 //

   770 //                        idCounter++;

   771 //                        }

   772 //                    else

   773 //                        {

   774 //                        delete bitmap;

   775 //                        delete mask;

   776 //

   777 //                        TAppIcon appIconEntry;

   778 //                        appIconEntry.iId = EFixedIconEmpty;

   779 //                        appIconEntry.iUid = appUid;

   780 //

   781 //                        iAppIconList->AppendL(appIconEntry);

   782 //                        }

   783 //                    }

   784 //

   785 //                else if (appUid != KNullUid && iconId >= 0)

   786 //                    {

   787 //                    // we already have already generated an icon for this uid, use it

   788 //                    fileEntry.iIconId = iconId;

   789 //                    }

   790 //                }

   791 //            }

   792 //        }

   793 //

   794 //    CleanupStack::Pop(); //iconArray

   795 //	return iconArray;

   796 //

   797 //	}

   798 //

   799 // --------------------------------------------------------------------------------------------

   800 

   801 //void CFileBrowserFileUtils::AppendGulIconToIconArrayL(CAknIconArray* aIconArray, const TDesC& aIconFile, TInt aIconId, TInt aMaskId, const TAknsItemID aAknsItemId)

   802 //    {

   803 //    CGulIcon* icon = AknsUtils::CreateGulIconL(

   804 //            AknsUtils::SkinInstance(),

   805 //            aAknsItemId,

   806 //            aIconFile,

   807 //            aIconId,

   808 //            aMaskId);

   809 //    CleanupStack::PushL(icon);

   810 //	

   811 //	icon->SetBitmapsOwnedExternally(EFalse);

   812 //	aIconArray->AppendL(icon);

   813 //	

   814 //	CleanupStack::Pop(); //icon          

   815 //    }

   816 

   817 // --------------------------------------------------------------------------------------------

   818 

   819 TInt CFileBrowserFileUtils::AppIconIdForUid(TUid aUid)

   820     {

   821     TInt result(KErrNotFound);

   822     

   823     for (TInt i=0; i<iAppIconList->Count(); i++)

   824         {

   825         if (iAppIconList->At(i).iUid == aUid)

   826             {

   827             result = iAppIconList->At(i).iId;

   828             break;

   829             }

   830         }

   831     

   832     return result;

   833     }

   834 

   835 // --------------------------------------------------------------------------------------------

   836 

   837 TUid CFileBrowserFileUtils::GetAppUid(TFileEntry aFileEntry)

   838     {

   839     TFileName fullPath;

   840     fullPath.Copy(aFileEntry.iPath);

   841     fullPath.Append(aFileEntry.iEntry.iName);

   842     

   843     TParse parsedName;

   844     parsedName.Set(fullPath, NULL, NULL);

   845 

   846     // this will boost performance in \sys\bin folder    

   847     if (parsedName.Ext().CompareF(_L(".dll")) == 0 || parsedName.Ext().CompareF(_L(".rsc")) == 0)

   848         return KNullUid;

   849     

   850     TInt err1(KErrNone), err2(KErrNone);

   851     TUid appUid;

   852     TDataType dataType;

   853     TBool isProgram;

   854     

   855     err1 = iEngine->LsSession().AppForDocument(fullPath, appUid, dataType);

   856     err2 = iEngine->LsSession().IsProgram(fullPath, isProgram);

   857         

   858     if (err1 == KErrNone && err2 == KErrNone)

   859         {

   860         if (isProgram)

   861             {

   862             // get the real app Uid from the app list

   863             TApaAppInfo appInfo;

   864             iEngine->LsSession().GetAllApps();

   865 

   866             while (iEngine->LsSession().GetNextApp(appInfo) == KErrNone)

   867                 {

   868                 if (fullPath.CompareF(appInfo.iFullName) == 0)

   869                     return appInfo.iUid;

   870                 }

   871             }

   872         else

   873             {

   874             // return the app Uid associated for it

   875             return appUid;

   876             }            

   877         }

   878 

   879     return KNullUid;

   880     }

   881 

   882 

   883 CFileEntryList* CFileBrowserFileUtils::FileEntries() const

   884 {

   885     return iFileEntryList;

   886 }

   887 CDriveEntryList* CFileBrowserFileUtils::DriveEntries() const

   888 {

   889     return iDriveEntryList;

   890 }

   891 

   892 //// --------------------------------------------------------------------------------------------

   893 //

   894 //CDesCArray* CFileBrowserFileUtils::GenerateItemTextArrayL()

   895 //    {

   896 //    iTextArray = new(ELeave) CDesCArrayFlat(64);

   897 ////    CleanupStack::PushL(textArray);

   898 //

   899 //    if (IsDriveListViewActive())

   900 //        {

   901 //        _LIT(KSimpleDriveEntry, "%d\t%c: <%S>\t\t");

   902 //        _LIT(KExtendedDriveEntry, "%d\t%c: <%S>\t%LD / %LD kB\t");

   903 //

   904 //        for (TInt i=0; i<iDriveEntryList->Count(); i++)

   905 //            {

   906 //            TFileName textEntry;

   907 //            TDriveEntry driveEntry = iDriveEntryList->At(i);

   908 //

   909 //            if (iEngine->Settings().iFileViewMode == EFileViewModeSimple)

   910 //                {

   911 //                textEntry.Format(KSimpleDriveEntry, driveEntry.iIconId, TUint(driveEntry.iLetter), &driveEntry.iMediaTypeDesc);

   912 //                }

   913 //            else if (iEngine->Settings().iFileViewMode == EFileViewModeExtended)

   914 //                {

   915 //                textEntry.Format(KExtendedDriveEntry, driveEntry.iIconId, TUint(driveEntry.iLetter), &driveEntry.iMediaTypeDesc, driveEntry.iVolumeInfo.iFree/1024, driveEntry.iVolumeInfo.iSize/1024);

   916 //                }

   917 //

   918 //            iTextArray->AppendL(textEntry);

   919 //            }

   920 //        }

   921 //

   922 //    else

   923 //        {

   924 //        _LIT(KSimpleFileEntry, "%d\t%S\t\t");

   925 //        _LIT(KExtendedFileEntry, "%d\t%S\t%S\t");

   926 //

   927 //        for (TInt i=0; i<iFileEntryList->Count(); i++)

   928 //            {

   929 //            TFileName textEntry;

   930 //            TFileEntry fileEntry = iFileEntryList->At(i);

   931 //

   932 //            // format text line entries

   933 //            if (iEngine->Settings().iFileViewMode == EFileViewModeSimple)

   934 //                {

   935 //                textEntry.Format(KSimpleFileEntry, fileEntry.iIconId, &fileEntry.iEntry.iName);

   936 //                }

   937 //            else if (iEngine->Settings().iFileViewMode == EFileViewModeExtended)

   938 //                {

   939 //                TBuf<128> extraData;

   940 //

   941 //                // append entry date

   942 //                TTime entryModified = fileEntry.iEntry.iModified;

   943 //                if ( iTz.ConvertToLocalTime( entryModified ) == KErrNone )

   944 //                    {

   945 //                    entryModified = fileEntry.iEntry.iModified;

   946 //                    }

   947 //

   948 //                _LIT(KCurrentDate,"%D%M%*Y%/0%1%/1%2%/2%3%/3 %-B%:0%J%:1%T%:2%S%:3%+B");

   949 //                entryModified.FormatL(extraData, KCurrentDate);

   950 //

   951 //                // for a directory append number of entries and for a file the file size

   952 //                if (fileEntry.iEntry.IsDir() && fileEntry.iDirEntries >= 0)

   953 //                    {

   954 //                    extraData.Append(_L(" - "));

   955 //                    extraData.AppendNum(fileEntry.iDirEntries);

   956 //

   957 //                    if (fileEntry.iDirEntries == 1)

   958 //                        extraData.Append(_L(" entry"));

   959 //                    else

   960 //                        extraData.Append(_L(" entries"));

   961 //                    }

   962 //

   963 //                // normal file entry

   964 //                else if (!fileEntry.iEntry.IsDir())

   965 //                    {

   966 //                    extraData.Append(_L(" - "));

   967 //

   968 //                    if (fileEntry.iEntry.iSize < 1024)

   969 //                        {

   970 //                        extraData.AppendNum(fileEntry.iEntry.iSize);

   971 //                        extraData.Append(_L(" B"));

   972 //                        }

   973 //                    else if (fileEntry.iEntry.iSize < 1024*1024)

   974 //                        {

   975 //                        TReal sizeKB = (TReal)fileEntry.iEntry.iSize / 1024;

   976 //                        extraData.AppendNum(sizeKB, TRealFormat(KDefaultRealWidth, 1));

   977 //                        extraData.Append(_L(" kB"));

   978 //                        }

   979 //                    else

   980 //                        {

   981 //                        TReal sizeMB = (TReal)fileEntry.iEntry.iSize / (1024*1024);

   982 //                        extraData.AppendNum(sizeMB, TRealFormat(KDefaultRealWidth, 1));

   983 //                        extraData.Append(_L(" MB"));

   984 //                        }

   985 //                    }

   986 //

   987 //                // append attribute flags if any

   988 //                TBuf<4> atts;

   989 //                if (fileEntry.iEntry.IsArchive())

   990 //                    atts.Append(_L("A"));

   991 //                if (fileEntry.iEntry.IsHidden())

   992 //                    atts.Append(_L("H"));

   993 //                if (fileEntry.iEntry.IsReadOnly())

   994 //                    atts.Append(_L("R"));

   995 //                if (fileEntry.iEntry.IsSystem())

   996 //                    atts.Append(_L("S"));

   997 //

   998 //                if (atts.Length() > 0)

   999 //                    {

  1000 //                    extraData.Append(_L(" - ["));

  1001 //                    extraData.Append(atts);

  1002 //                    extraData.Append(_L("]"));

  1003 //                    }

  1004 //

  1005 //                // format

  1006 //                textEntry.Format(KExtendedFileEntry, fileEntry.iIconId, &fileEntry.iEntry.iName, &extraData);

  1007 //                }

  1008 //

  1009 //            iTextArray->AppendL(textEntry);

  1010 //            }

  1011 //        }

  1012 //

  1013 ////    CleanupStack::Pop(); //textArray

  1014 //    return iTextArray;

  1015 //    }

  1016     

  1017 // --------------------------------------------------------------------------------------------

  1018 

  1019 void CFileBrowserFileUtils::GenerateDirectoryDataL()

  1020     {

  1021     if (iListingMode == ENormalEntries)

  1022         {

  1023         if (IsDriveListViewActive())

  1024             GetDriveListL();    

  1025         else

  1026             GetDirectoryListingL();        

  1027         }

  1028     }

  1029 

  1030 // --------------------------------------------------------------------------------------------

  1031 

  1032 void CFileBrowserFileUtils::GetDriveListL()

  1033     {

  1034     TDriveList driveList;

  1035     

  1036     // get drive listing depending of the support for network drives

  1037     if (iEngine->Settings().iSupportNetworkDrives)

  1038         {

  1039         #ifndef __SERIES60_30__

  1040             #ifndef __SERIES60_31__

  1041                 User::LeaveIfError(iFs.DriveList(driveList, KDriveAttAll));

  1042             #endif

  1043         #else    

  1044             User::LeaveIfError(iFs.DriveList(driveList));

  1045         #endif        

  1046         }

  1047     else

  1048         {

  1049         User::LeaveIfError(iFs.DriveList(driveList));

  1050         }

  1051     

  1052     iDriveEntryList->Reset();        

  1053     

  1054     for (TInt i=0; i<KMaxDrives; i++)

  1055         {

  1056         if (driveList[i])

  1057             {

  1058             TDriveEntry driveEntry;

  1059             

  1060             // set default icon

  1061             driveEntry.iIconId = EFixedIconPhoneMemory;

  1062 

  1063             // get drive letter and number 

  1064             driveEntry.iLetter = 'A' + i;

  1065             iFs.CharToDrive(driveEntry.iLetter, driveEntry.iNumber);

  1066             

  1067             // get volume info and check errors

  1068             if (iFs.Volume(driveEntry.iVolumeInfo, driveEntry.iNumber) == KErrNone)

  1069                 {

  1070                 // set media type descriptor

  1071                 TInt mediaType = driveEntry.iVolumeInfo.iDrive.iType;

  1072                 TBool extMountable( EFalse );

  1073                 

  1074                 if (mediaType == EMediaNotPresent)

  1075                     driveEntry.iMediaTypeDesc = _L("Not present");

  1076                 else if (mediaType ==EMediaUnknown )

  1077                     driveEntry.iMediaTypeDesc = _L("Unknown");

  1078                 else if (mediaType ==EMediaFloppy )

  1079                     driveEntry.iMediaTypeDesc = _L("Floppy");

  1080                 else if (mediaType == EMediaHardDisk)

  1081                     driveEntry.iMediaTypeDesc = _L("Mass storage");

  1082                 else if (mediaType == EMediaCdRom)

  1083                     driveEntry.iMediaTypeDesc = _L("CD-ROM");

  1084                 else if (mediaType == EMediaRam)

  1085                     driveEntry.iMediaTypeDesc = _L("RAM");

  1086                 else if (mediaType == EMediaFlash)

  1087                     driveEntry.iMediaTypeDesc = _L("Flash");

  1088                 else if (mediaType == EMediaRom)

  1089                     driveEntry.iMediaTypeDesc = _L("ROM");

  1090                 else if (mediaType == EMediaRemote)

  1091                     driveEntry.iMediaTypeDesc = _L("Remote");

  1092                 else if (mediaType == EMediaNANDFlash)

  1093                     driveEntry.iMediaTypeDesc = _L("NAND flash");

  1094                 

  1095                 // get real size of the ROM drive

  1096                 if (mediaType == EMediaRom)

  1097                     {

  1098                     TMemoryInfoV1Buf ramMemory;

  1099                     UserHal::MemoryInfo(ramMemory);

  1100                     driveEntry.iVolumeInfo.iSize = ramMemory().iTotalRomInBytes;

  1101                     }

  1102                 

  1103                 // set attribute descripitions

  1104                 if (driveEntry.iVolumeInfo.iDrive.iBattery == EBatNotSupported)

  1105                     driveEntry.iAttributesDesc.Append(_L("Battery not supported"));

  1106                 else if (driveEntry.iVolumeInfo.iDrive.iBattery == EBatGood)

  1107                     driveEntry.iAttributesDesc.Append(_L("Battery good"));

  1108                 else if (driveEntry.iVolumeInfo.iDrive.iBattery == EBatLow)

  1109                     driveEntry.iAttributesDesc.Append(_L("Battery low"));

  1110                 else

  1111                     driveEntry.iAttributesDesc.Append(_L("Battery state unknown"));

  1112                 

  1113                 if (driveEntry.iVolumeInfo.iDrive.iDriveAtt & KDriveAttLocal)

  1114                     driveEntry.iAttributesDesc.Append(_L(" + Local"));

  1115                 if (driveEntry.iVolumeInfo.iDrive.iDriveAtt & KDriveAttRom)

  1116                     driveEntry.iAttributesDesc.Append(_L(" + ROM"));

  1117                 if (driveEntry.iVolumeInfo.iDrive.iDriveAtt & KDriveAttRedirected)

  1118                     driveEntry.iAttributesDesc.Append(_L("+ Redirected"));

  1119                 if (driveEntry.iVolumeInfo.iDrive.iDriveAtt & KDriveAttSubsted)

  1120                     driveEntry.iAttributesDesc.Append(_L(" + Substed"));

  1121                 if (driveEntry.iVolumeInfo.iDrive.iDriveAtt & KDriveAttInternal)

  1122                     driveEntry.iAttributesDesc.Append(_L(" + Internal"));

  1123                 if (driveEntry.iVolumeInfo.iDrive.iDriveAtt & KDriveAttRemovable)

  1124                     {

  1125                     driveEntry.iAttributesDesc.Append(_L(" + Removable"));

  1126 #if (!defined __SERIES60_30__ && !defined __SERIES60_31__)

  1127                     TUint drvStatus( 0 );

  1128                     if ( !DriveInfo::GetDriveStatus( iFs, driveEntry.iNumber, drvStatus ) &&

  1129                          drvStatus & DriveInfo::EDriveExternallyMountable &&

  1130                          drvStatus & DriveInfo::EDriveInternal )

  1131                         {

  1132                         extMountable = ETrue;

  1133                         // iMediaTypeDesc already set as "Mass storage" 

  1134                         }