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 

   447             }

   448 	else

   449             {

   450             // maintain requests

   451             iCurrentEntry++;

   452 

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

   454 

   455             ExecuteCommand();

   456             }

   457     }    

   458 // --------------------------------------------------------------------------------------------

   459 

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

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

   462     {

   463 //    iProgressDialog = NULL;

   464 //    iProgressInfo = NULL;

   465 //    iWaitDialog = NULL;

   466     

   467     // check if cancel button was pressed

   468 //    if (aButtonId == EAknSoftkeyCancel)

   469 //        {

   470         // cancel the active object, command executer 

   471         Cancel();

   472         

   473         iFileOps->CancelOp();

   474         

   475         ResetCommandArray();

   476 

   477         isProgressDialog = EFalse;

   478 

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

   480 //        }

   481     }

   482     

   483 // --------------------------------------------------------------------------------------------

   484 

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

   486     {

   487     if (iCommandArray)

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

   489     else

   490         User::Leave(KErrNotReady);

   491     }

   492 

   493 // --------------------------------------------------------------------------------------------

   494 

   495 TInt CFileBrowserFileUtils::CommandArrayCount() const

   496     {

   497     TInt count(0);

   498     

   499     if (iCommandArray)

   500         count = iCommandArray->Count();

   501     

   502     return count;

   503     }

   504 

   505 // --------------------------------------------------------------------------------------------

   506 

   507 void CFileBrowserFileUtils::ResetCommandArray()

   508     {

   509     // delete params first

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

   511         {

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

   513             {

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

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

   516             }

   517         }

   518 

   519     // reset the entries

   520     iCommandArray->Reset();

   521     }

   522                     

   523 // --------------------------------------------------------------------------------------------

   524 

   525 void CFileBrowserFileUtils::HandleSettingsChangeL()

   526     {

   527 	// TODO

   528 

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

   530 //        {

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

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

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

   534         RefreshViewL();

   535 //        }

   536     }

   537 

   538 // --------------------------------------------------------------------------------------------

   539 

   540 void CFileBrowserFileUtils::SetSortModeL(TInt aSortMode)

   541     {

   542     iSortMode = aSortMode;

   543     RefreshViewL();

   544     }

   545     

   546 // --------------------------------------------------------------------------------------------

   547 

   548 void CFileBrowserFileUtils::SetOrderModeL(TInt aOrderMode)

   549     {

   550     iOrderMode = aOrderMode;

   551     RefreshViewL();

   552     }

   553 

   554 // --------------------------------------------------------------------------------------------

   555 

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

   557     {

   558 	// TODO

   559 	/*

   560     if(aType != EEventKey)

   561         return EKeyWasNotConsumed;

   562     

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

   564                             (aKeyEvent.iModifiers & EModifierLeftShift) ||

   565                             (aKeyEvent.iModifiers & EModifierRightShift);

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

   567                               (aKeyEvent.iModifiers & EModifierRightCtrl); 

   568     

   569     // handle left arrow key press

   570     if (aKeyEvent.iCode == EKeyLeftArrow)

   571         {

   572         MoveUpOneLevelL();

   573         return EKeyWasConsumed;

   574         }

   575     

   576     // handle right arrow key press

   577     else if (aKeyEvent.iCode == EKeyRightArrow)

   578         {

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

   580             {

   581             MoveDownToDirectoryL();

   582             return EKeyWasConsumed;

   583             }

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

   585             {

   586             MoveDownToDirectoryL();

   587             return EKeyWasConsumed;

   588             }        

   589         }    

   590 

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

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

   593         {

   594         return EKeyWasNotConsumed;

   595         }

   596     

   597     // handle OK/Enter keys

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

   599         {

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

   601             {

   602             MoveDownToDirectoryL();

   603             return EKeyWasConsumed;

   604             }

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

   606             {

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

   608             

   609             if (fileEntry.iEntry.IsDir())

   610                 MoveDownToDirectoryL();

   611             else

   612                 OpenCommonFileActionQueryL();

   613             

   614             return EKeyWasConsumed;

   615             } 

   616         }

   617     

   618     // handle Delete/Backspace keys

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

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

   621         {

   622         DeleteL();

   623         return EKeyWasConsumed;

   624         }

   625     */                      

   626     return EKeyWasNotConsumed;

   627     }        

   628 // --------------------------------------------------------------------------------------------

   629 

   630 void CFileBrowserFileUtils::RefreshViewL()

   631     {

   632 	// TODO

   633 

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

   635 //        {

   636 //        // create a list box if it doesn't already exist

   637 //        if (!iEngine->FileListContainer()->ListBox())

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

   639 //

   640 //        // clear selections if any

   641 //        iEngine->FileListContainer()->ListBox()->ClearSelection();

   642 //

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

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

   645         

   646         // read directory listing

   647         GenerateDirectoryDataL();

   648         

   649 //        // set an icon array

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

   651 //

   652 //        // set text items

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

   654 

   655 //        // make sure that the current item index is not out of array

   656 //        if (iEngine->FileListContainer()->CurrentListBoxItemIndex() == -1 && // -1 is a hardcoded value meaning that no current item index

   657 //                iEngine->FileListContainer()->ListBox()->Model()->NumberOfItems() > 0)

   658 //            iEngine->FileListContainer()->ListBox()->SetCurrentItemIndex( iEngine->FileListContainer()->ListBox()->Model()->NumberOfItems() - 1 );

   659 //

   660 //        }

   661     

   662 //        iEngine->FileListContainer()->UpdateToolbar();

   663 

   664         }

   665     

   666 // --------------------------------------------------------------------------------------------

   667 

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

   669 //    {

   670 //	// TODO

   671 //

   672 //    CAknIconArray* iconArray = NULL;

   673 //

   674 //    if (aGenerateNewBasicIconArray)

   675 //        {

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

   677 //        }

   678 //    else

   679 //        {

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

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

   682 //

   683 //        if (!iconArray)

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

   685 //        }

   686 //

   687 //

   688 //    CleanupStack::PushL(iconArray);

   689 //

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

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

   692 //        {

   693 //        // reset arrays

   694 //        iconArray->Reset();

   695 //        iAppIconList->Reset();

   696 //

   697 //        // get default control color

   698 //        TRgb defaultColor;

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

   700 //

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

   702 //        CFbsBitmap* markBitmap = NULL;

   703 //        CFbsBitmap* markBitmapMask = NULL;

   704 //

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

   706 //                KAknsIIDQgnIndiMarkedAdd,

   707 //                KAknsIIDQsnIconColors,

   708 //                EAknsCIQsnIconColorsCG13,

   709 //                markBitmap,

   710 //                markBitmapMask,

   711 //                AknIconUtils::AvkonIconFileName(),

   712 //                EMbmAvkonQgn_indi_marked_add,

   713 //                EMbmAvkonQgn_indi_marked_add_mask,

   714 //                defaultColor

   715 //                );

   716 //

   717 //        // 0 marking indicator

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

   719 //        iconArray->AppendL(markIcon);

   720 //

   721 //        // 1 empty

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

   723 //                                  EMbmAvkonQgn_prop_empty, EMbmAvkonQgn_prop_empty_mask, KAknsIIDQgnPropEmpty);

   724 //        // 2 phone memory

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

   726 //                                  EMbmAvkonQgn_prop_phone_memc, EMbmAvkonQgn_prop_phone_memc_mask, KAknsIIDQgnPropPhoneMemc);

   727 //        // 3 memory card

   728 //        AppendGulIconToIconArrayL(iconArray, KMemoryCardUiBitmapFile,

   729 //                                  EMbmAknmemorycarduiQgn_prop_mmc_memc, EMbmAknmemorycarduiQgn_prop_mmc_memc_mask, KAknsIIDQgnPropMmcMemc);

   730 //        // 4 memory card disabled

   731 //        AppendGulIconToIconArrayL(iconArray, KMemoryCardUiBitmapFile,

   732 //                                  EMbmAknmemorycarduiQgn_prop_mmc_non, EMbmAknmemorycarduiQgn_prop_mmc_non_mask, KAknsIIDQgnPropMmcNon);

   733 //        // 5 folder

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

   735 //                                  EMbmAvkonQgn_prop_folder_small, EMbmAvkonQgn_prop_folder_small_mask, KAknsIIDQgnPropFolderSmall);

   736 //        // 6 folder with subfolders

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

   738 //                                  EMbmAvkonQgn_prop_folder_sub_small, EMbmAvkonQgn_prop_folder_sub_small_mask, KAknsIIDQgnPropFolderSubSmall);

   739 //        // 7 current folder

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

   741 //                                  EMbmAvkonQgn_prop_folder_current, EMbmAvkonQgn_prop_folder_current_mask, KAknsIIDQgnPropFolderCurrent);

   742 //        }

   743 //

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

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

   746 //        {

   747 //        // init id counter

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

   749 //

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

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

   752 //            {

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

   754 //

   755 //            // just check for normal files

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

   757 //                {

   758 //                TUid appUid = GetAppUid(fileEntry);

   759 //                TInt iconId = AppIconIdForUid(appUid);

   760 //

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

   762 //                    {

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

   764 //                    CFbsBitmap* bitmap = NULL;

   765 //                    CFbsBitmap* mask = NULL;

   766 //                    CGulIcon* appIcon = NULL;

   767 //

   768 //                    TRAPD(err,

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

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

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

   772 //                        );

   773 //

   774 //                    if (err == KErrNone)

   775 //                        {

   776 //                        TAppIcon appIconEntry;

   777 //                        appIconEntry.iId = idCounter;

   778 //                        appIconEntry.iUid = appUid;

   779 //

   780 //                        appIcon->SetBitmapsOwnedExternally(EFalse);

   781 //                        iconArray->AppendL(appIcon);

   782 //                        iAppIconList->AppendL(appIconEntry);

   783 //

   784 //                        fileEntry.iIconId = idCounter;

   785 //

   786 //                        idCounter++;

   787 //                        }

   788 //                    else

   789 //                        {

   790 //                        delete bitmap;

   791 //                        delete mask;

   792 //

   793 //                        TAppIcon appIconEntry;

   794 //                        appIconEntry.iId = EFixedIconEmpty;

   795 //                        appIconEntry.iUid = appUid;

   796 //

   797 //                        iAppIconList->AppendL(appIconEntry);

   798 //                        }

   799 //                    }

   800 //

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

   802 //                    {

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

   804 //                    fileEntry.iIconId = iconId;

   805 //                    }

   806 //                }

   807 //            }

   808 //        }

   809 //

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

   811 //	return iconArray;

   812 //

   813 //	}

   814 //

   815 // --------------------------------------------------------------------------------------------

   816 

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

   818 //    {

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

   820 //            AknsUtils::SkinInstance(),

   821 //            aAknsItemId,

   822 //            aIconFile,

   823 //            aIconId,

   824 //            aMaskId);

   825 //    CleanupStack::PushL(icon);

   826 //	

   827 //	icon->SetBitmapsOwnedExternally(EFalse);

   828 //	aIconArray->AppendL(icon);

   829 //	

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

   831 //    }

   832 

   833 // --------------------------------------------------------------------------------------------

   834 

   835 TInt CFileBrowserFileUtils::AppIconIdForUid(TUid aUid)

   836     {

   837     TInt result(KErrNotFound);

   838     

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

   840         {

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

   842             {

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

   844             break;

   845             }

   846         }

   847     

   848     return result;

   849     }

   850 

   851 // --------------------------------------------------------------------------------------------

   852 

   853 TUid CFileBrowserFileUtils::GetAppUid(TFileEntry aFileEntry)

   854     {

   855     TFileName fullPath;

   856     fullPath.Copy(aFileEntry.iPath);

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

   858     

   859     TParse parsedName;

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

   861 

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

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

   864         return KNullUid;

   865     

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

   867     TUid appUid;

   868     TDataType dataType;

   869     TBool isProgram;

   870     

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

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

   873         

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

   875         {

   876         if (isProgram)

   877             {

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

   879             TApaAppInfo appInfo;

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

   881 

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

   883                 {

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

   885                     return appInfo.iUid;

   886                 }

   887             }

   888         else

   889             {

   890             // return the app Uid associated for it

   891             return appUid;

   892             }            

   893         }

   894 

   895     return KNullUid;

   896     }

   897 

   898 

   899 CFileEntryList* CFileBrowserFileUtils::FileEntries() const

   900 {

   901     return iFileEntryList;

   902 }

   903 CDriveEntryList* CFileBrowserFileUtils::DriveEntries() const

   904 {

   905     return iDriveEntryList;

   906 }

   907 

   908 //// --------------------------------------------------------------------------------------------

   909 //

   910 //CDesCArray* CFileBrowserFileUtils::GenerateItemTextArrayL()

   911 //    {

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

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

   914 //

   915 //    if (IsDriveListViewActive())

   916 //        {

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

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

   919 //

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

   921 //            {

   922 //            TFileName textEntry;

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

   924 //

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

   926 //                {

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

   928 //                }

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

   930 //                {

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

   932 //                }

   933 //

   934 //            iTextArray->AppendL(textEntry);

   935 //            }

   936 //        }

   937 //

   938 //    else

   939 //        {

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

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

   942 //

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

   944 //            {

   945 //            TFileName textEntry;

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

   947 //

   948 //            // format text line entries

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

   950 //                {

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

   952 //                }

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

   954 //                {

   955 //                TBuf<128> extraData;

   956 //

   957 //                // append entry date

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

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

   960 //                    {

   961 //                    entryModified = fileEntry.iEntry.iModified;

   962 //                    }

   963 //

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

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

   966 //

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

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

   969 //                    {

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

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

   972 //

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

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

   975 //                    else

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

   977 //                    }

   978 //

   979 //                // normal file entry

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

   981 //                    {

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

   983 //

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

   985 //                        {

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

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

   988 //                        }

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

   990 //                        {

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

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

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

   994 //                        }

   995 //                    else

   996 //                        {

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

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

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

  1000 //                        }

  1001 //                    }

  1002 //

  1003 //                // append attribute flags if any

  1004 //                TBuf<4> atts;

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

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

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

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

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

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

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

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

  1013 //

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

  1015 //                    {

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

  1017 //                    extraData.Append(atts);

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

  1019 //                    }

  1020 //

  1021 //                // format

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

  1023 //                }

  1024 //

  1025 //            iTextArray->AppendL(textEntry);

  1026 //            }

  1027 //        }

  1028 //

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

  1030 //    return iTextArray;

  1031 //    }

  1032     

  1033 // --------------------------------------------------------------------------------------------

  1034 

  1035 void CFileBrowserFileUtils::GenerateDirectoryDataL()

  1036     {

  1037     if (iListingMode == ENormalEntries)

  1038         {

  1039         if (IsDriveListViewActive())

  1040             GetDriveListL();    

  1041         else

  1042             GetDirectoryListingL();        

  1043         }

  1044     }

  1045 

  1046 // --------------------------------------------------------------------------------------------

  1047 

  1048 void CFileBrowserFileUtils::GetDriveListL()

  1049     {

  1050     TDriveList driveList;

  1051     

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

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

  1054         {

  1055         #ifndef __SERIES60_30__

  1056             #ifndef __SERIES60_31__

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

  1058             #endif

  1059         #else    

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

  1061         #endif        

  1062         }

  1063     else

  1064         {

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

  1066         }

  1067     

  1068     iDriveEntryList->Reset();        

  1069     

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

  1071         {

  1072         if (driveList[i])

  1073             {

  1074             TDriveEntry driveEntry;

  1075             

  1076             // set default icon

  1077             driveEntry.iIconId = EFixedIconPhoneMemory;

  1078 

  1079             // get drive letter and number 

  1080             driveEntry.iLetter = 'A' + i;

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

  1082             

  1083             // get volume info and check errors

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

  1085                 {

  1086                 // set media type descriptor

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

  1088                 TBool extMountable( EFalse );

  1089                 

  1090                 if (mediaType == EMediaNotPresent)

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

  1092                 else if (mediaType ==EMediaUnknown )

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

  1094                 else if (mediaType ==EMediaFloppy )

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

  1096                 else if (mediaType == EMediaHardDisk)

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

  1098                 else if (mediaType == EMediaCdRom)

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

  1100                 else if (mediaType == EMediaRam)

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

  1102                 else if (mediaType == EMediaFlash)

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

  1104                 else if (mediaType == EMediaRom)

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

  1106                 else if (mediaType == EMediaRemote)

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

  1108                 else if (mediaType == EMediaNANDFlash)

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

  1110                 

  1111                 // get real size of the ROM drive

  1112                 if (mediaType == EMediaRom)

  1113                     {

  1114                     TMemoryInfoV1Buf ramMemory;

  1115                     UserHal::MemoryInfo(ramMemory);

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

  1117                     }

  1118                 

  1119                 // set attribute descripitions

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

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

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

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

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

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

  1126                 else

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

  1128                 

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

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

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

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

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

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