diff -r 000000000000 -r a03f92240627 memspy/Engine/Source/Helpers/MemSpyEngineHelperFileSystem.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/memspy/Engine/Source/Helpers/MemSpyEngineHelperFileSystem.cpp	Tue Feb 02 01:57:15 2010 +0200
@@ -0,0 +1,1191 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+#include <memspy/engine/memspyenginehelperfilesystem.h>
+
+// System includes
+#include <f32file.h>
+
+// Driver includes
+#include <memspy/driver/memspydriverclient.h>
+
+// User includes
+#include <memspy/engine/memspyengine.h>
+#include <memspy/engine/memspyengineobjectthread.h>
+#include <memspy/engine/memspyengineobjectprocess.h>
+#include <memspy/engine/memspyengineutils.h>
+#include <memspy/engine/memspyenginehelperchunk.h>
+#include <memspy/engine/memspyengineoutputsink.h>
+#include <memspy/engine/memspyengineoutputlist.h>
+#include "MemSpyEngineOutputListItem.h"
+
+// Remap of E32 constant since this value only exists in recent v9.3 builds and MemSpy needs to build on v9.1
+const TUint KMemSpyDriveAttPageable = 0x100; // KDriveAttPageable
+const TUint KMemSpyMediaAttPageable = 0x200; // KMediaAttPageable
+
+// Literal constants
+_LIT( KMemSpyVolumeLabelNotSet, "None" );
+
+
+CMemSpyEngineHelperFileSystem::CMemSpyEngineHelperFileSystem( CMemSpyEngine& aEngine )
+:   iEngine( aEngine )
+    {
+    }
+
+    
+CMemSpyEngineHelperFileSystem::~CMemSpyEngineHelperFileSystem()
+    {
+    }
+
+
+void CMemSpyEngineHelperFileSystem::ConstructL()
+    {
+    iFileServerProcessId = MemSpyEngineUtils::IdentifyFileServerProcessIdL();
+    }
+
+
+CMemSpyEngineHelperFileSystem* CMemSpyEngineHelperFileSystem::NewL( CMemSpyEngine& aEngine )
+    {
+    CMemSpyEngineHelperFileSystem* self = new(ELeave) CMemSpyEngineHelperFileSystem( aEngine );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    return self;
+    }
+
+
+EXPORT_C CMemSpyEngineDriveList* CMemSpyEngineHelperFileSystem::DriveListL()
+    {
+    CMemSpyEngineDriveList* list = CMemSpyEngineDriveList::NewLC( iEngine.FsSession() );
+    CleanupStack::Pop( list );
+    return list;
+    }
+
+
+EXPORT_C TDriveNumber CMemSpyEngineHelperFileSystem::GetSystemDrive()
+    {
+    TDriveNumber ret = EDriveC;
+#ifndef __WINS__
+    const TInt KRFsGetSystemDriveOrdinal = 336;
+    typedef TDriveNumber(*TRFsGetSystemDriveFunc)();
+    //
+    RLibrary lib;
+    const TInt loadErr = lib.Load( _L("EFSRV.DLL") );
+#ifdef _DEBUG
+    RDebug::Printf( "CMemSpyEngineHelperFileSystem::GetSystemDrive() - dll load: %d", loadErr );
+#endif
+    if  ( loadErr == KErrNone )
+        {
+        TLibraryFunction ordinal = lib.Lookup( KRFsGetSystemDriveOrdinal );
+#ifdef _DEBUG
+        RDebug::Printf( "CMemSpyEngineHelperFileSystem::GetSystemDrive() - ordinal: 0x%08x", ordinal );
+#endif
+        //
+        if  ( ordinal )
+            {
+            TRFsGetSystemDriveFunc func = (TRFsGetSystemDriveFunc) ordinal;
+            ret = (*func)();
+#ifdef _DEBUG
+            RDebug::Printf( "CMemSpyEngineHelperFileSystem::GetSystemDrive() - drive: %c:\\", 'A' + ret);
+#endif
+            }
+        //
+        lib.Close();
+        }
+#endif
+    //
+    return ret;
+    }
+
+
+EXPORT_C void CMemSpyEngineHelperFileSystem::ListOpenFilesL()
+    {
+    TOpenFileScan scanner( iEngine.FsSession() );
+
+    _LIT( KMemSpyContext, "Open File Listing" );
+    _LIT( KMemSpyFolder, "OpenFiles" );
+    iEngine.Sink().DataStreamBeginL( KMemSpyContext, KMemSpyFolder );
+
+    _LIT(KHeading, "OPEN FILES");
+    iEngine.Sink().OutputSectionHeadingL( KHeading, '=' );
+    
+    // Set prefix for overall listing
+    _LIT(KOverallPrefix, "OpenFiles - ");
+    iEngine.Sink().OutputPrefixSetLC( KOverallPrefix );
+
+    CFileList* list = NULL;
+    scanner.NextL( list );
+    while( list != NULL )
+        {
+        CleanupStack::PushL( list );
+        ListOpenFilesL( *list, scanner.ThreadId() );
+        CleanupStack::PopAndDestroy( list );
+        //
+        list = NULL;
+        scanner.NextL( list );
+        }
+
+    CleanupStack::PopAndDestroy(); // prefix
+    iEngine.Sink().DataStreamEndL();
+    }
+
+
+EXPORT_C void CMemSpyEngineHelperFileSystem::ListOpenFilesL( const TThreadId& aThreadId )
+    {
+    TOpenFileScan scanner( iEngine.FsSession() );
+
+    _LIT( KMemSpyContext, "Open File Listing" );
+    _LIT( KMemSpyFolder, "OpenFiles" );
+    iEngine.Sink().DataStreamBeginL( KMemSpyContext, KMemSpyFolder );
+
+    _LIT(KHeading, "OPEN FILES");
+    iEngine.Sink().OutputSectionHeadingL( KHeading, '=' );
+    
+    // Set prefix for overall listing
+    _LIT(KOverallPrefix, "OpenFiles - ");
+    iEngine.Sink().OutputPrefixSetLC( KOverallPrefix );
+
+    CFileList* list = NULL;
+    scanner.NextL( list );
+    while( list != NULL )
+        {
+        if  ( scanner.ThreadId() == aThreadId )
+            {
+            CleanupStack::PushL( list );
+            ListOpenFilesL( *list, scanner.ThreadId() );
+            CleanupStack::Pop( list );
+            }
+        //
+        delete list;
+        list = NULL;
+        scanner.NextL( list );
+        }
+
+    CleanupStack::PopAndDestroy(); // prefix
+    iEngine.Sink().DataStreamEndL();
+    }
+
+
+void CMemSpyEngineHelperFileSystem::GetDriveNumberText( TDriveNumber aDriveNumber, TDes& aText )
+    {
+    const TInt offset = aDriveNumber - EDriveA;
+    const TChar driveChar = 'A' + offset;
+    aText.Copy( _L("EDrive") );
+    aText.Append( driveChar );
+    }
+
+
+void CMemSpyEngineHelperFileSystem::ListOpenFilesL( const CFileList& aList, const TThreadId& aThreadId )
+    {
+    _LIT( KLineFormatSpec, "%d %S %S %S %S" );
+    TBuf<64> timeBuf;
+    TMemSpySizeText valueBuf;
+
+    HBufC* itemBuf = HBufC::NewLC( 3 * KMaxFullName );
+    TPtr item( itemBuf->Des() );
+
+    TFullName threadName;
+    RThread thread;
+    if  ( iEngine.Driver().OpenThread( aThreadId, thread ) == KErrNone )
+        {
+        threadName = thread.FullName();
+        thread.Close();
+        }
+
+    const TInt entryCount = aList.Count();
+    for(TInt i=0; i<entryCount; i++)
+        {
+        const TEntry& entry = aList[ i ];
+
+        // Get time and size format strings
+        valueBuf = MemSpyEngineUtils::FormatSizeText( entry.iSize );
+        MemSpyEngineUtils::FormatTimeL( timeBuf, entry.iModified );
+
+        // Create item 
+        item.Format( KLineFormatSpec, 0, &entry.iName, &valueBuf, &timeBuf, &threadName );
+        iEngine.Sink().OutputLineL( item );
+        }
+
+    CleanupStack::PopAndDestroy( itemBuf );
+    }
+
+
+CMemSpyEngineOpenFileList* CMemSpyEngineHelperFileSystem::ListOpenFilesLC()
+    {
+    CMemSpyEngineOpenFileList* list = CMemSpyEngineOpenFileList::NewLC( iEngine );
+    return list;
+    }
+
+
+TProcessId CMemSpyEngineHelperFileSystem::FileServerProcessId() const
+    {
+    return iFileServerProcessId;
+    }
+
+
+const CMemSpyEngineChunkEntry* CMemSpyEngineHelperFileSystem::IdentifyCacheChunk( const CMemSpyEngineChunkList& aList, TInt& aIndex ) const
+    {
+    aIndex = KErrNotFound;
+    const CMemSpyEngineChunkEntry* ret = NULL;
+    //
+    const TInt count = aList.Count();
+    for( TInt i=0; i<count; i++ )
+        {
+        const CMemSpyEngineChunkEntry& entry = aList.At( i );
+        const TMemSpyDriverChunkInfo& info = entry.Info();
+        //
+        if  ( info.iType == EMemSpyDriverChunkTypeLocal )
+            {
+#ifdef _DEBUG
+            RDebug::Print( _L("CMemSpyEngineHelperFileSystem::IdentifyCacheChunk() - name: %S, pid: 0x%04x, f32Pid: 0x%04x, size: %d, max: %d, attribs: %d"), &info.iName, info.iOwnerId, (TUint) iFileServerProcessId, info.iSize, info.iMaxSize, info.iAttributes );
+#endif
+
+            if ( info.iOwnerId == FileServerProcessId() )
+                {
+                // Additionally, the chunk is disconnected.
+                const TBool isDisconnected = ( info.iAttributes & EMemSpyChunkAttributesDisconnected );
+#ifdef _DEBUG
+                RDebug::Printf( "CMemSpyEngineHelperFileSystem::IdentifyCacheChunk() - it is an f32 local chunk... isDisconnected: %d", isDisconnected );
+#endif
+
+                if  ( info.iSize > 0 && info.iMaxSize > 0 && isDisconnected )
+                    {
+                    aIndex = i;
+                    ret = &entry;
+#ifdef _DEBUG
+                    RDebug::Print( _L("CMemSpyEngineHelperFileSystem::IdentifyCacheChunk() - FOUND: %S, size: %d"), &info.iName, info.iSize );
+#endif
+                    break;
+                    }
+                }
+            }
+        }
+    //
+#ifdef _DEBUG
+    RDebug::Printf( "CMemSpyEngineHelperFileSystem::IdentifyCacheChunk() - END - ret: 0x%08x", ret );
+#endif
+    return ret;
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+CMemSpyEngineDriveList::CMemSpyEngineDriveList( RFs& aFsSession )
+:   CActive( EPriorityStandard ), iFsSession( aFsSession )
+    {
+    CActiveScheduler::Add( this );
+    }
+
+
+EXPORT_C CMemSpyEngineDriveList::~CMemSpyEngineDriveList()
+    {
+    Cancel();
+    //
+    iItems.ResetAndDestroy();
+    iItems.Close();
+    }
+
+
+void CMemSpyEngineDriveList::ConstructL()
+    {
+    TDriveList drives;
+    if  ( iFsSession.DriveList( drives ) == KErrNone )
+        {
+        for( TInt i=EDriveA; i<=EDriveZ; i++ )
+            {
+            const TDriveNumber drive = static_cast< TDriveNumber >( i );
+            if  ( drives[ i ] != KDriveAbsent )
+                {
+                TRAP_IGNORE( 
+                    CMemSpyEngineDriveEntry* driveEntry = CMemSpyEngineDriveEntry::NewLC( *this, drive );
+                    iItems.AppendL( driveEntry );
+                    CleanupStack::Pop( driveEntry );
+                    );
+                }
+            }
+        }
+
+    iFsSession.NotifyChange( ENotifyDisk, iStatus );
+    SetActive();
+    }
+
+
+CMemSpyEngineDriveList* CMemSpyEngineDriveList::NewLC( RFs& aFsSession )
+    {
+    CMemSpyEngineDriveList* self = new(ELeave) CMemSpyEngineDriveList( aFsSession );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    return self;
+    }
+
+
+void CMemSpyEngineDriveList::RunL()
+    {
+    iFsSession.NotifyChange( ENotifyDisk, iStatus );
+    SetActive();
+    //
+    NotifyListChangedL();
+    }
+
+
+void CMemSpyEngineDriveList::DoCancel()
+    {
+    iFsSession.NotifyChangeCancel();
+    }
+
+
+EXPORT_C void CMemSpyEngineDriveList::SetObserver( MMemSpyEngineDriveListObserver* aObserver )
+    {
+    iObserver = aObserver;
+    }
+
+
+EXPORT_C TInt CMemSpyEngineDriveList::Count() const
+    {
+    return iItems.Count();
+    }
+
+
+EXPORT_C CMemSpyEngineDriveEntry& CMemSpyEngineDriveList::At( TInt aIndex )
+    {
+    return *iItems[ aIndex ];
+    }
+
+
+EXPORT_C const CMemSpyEngineDriveEntry& CMemSpyEngineDriveList::At( TInt aIndex ) const
+    {
+    return *iItems[ aIndex ];
+    }
+
+
+EXPORT_C TInt CMemSpyEngineDriveList::ItemIndex( const CMemSpyEngineDriveEntry& aEntry ) const
+    {
+    TInt ret = KErrNotFound;
+    //
+    const TInt count = Count();
+    for( TInt i=0; i<count; i++ )
+        {
+        const CMemSpyEngineDriveEntry* item = iItems[ i ];
+        //
+        if  ( item == &aEntry )
+            {
+            ret = i;
+            break;
+            }
+        }
+    //
+    return ret;
+    }
+
+
+EXPORT_C CMemSpyEngineDriveEntry* CMemSpyEngineDriveList::EntryByDriveNumber( TDriveNumber aDrive )
+    {
+    CMemSpyEngineDriveEntry* ret = NULL;
+    //
+    const TInt count = Count();
+    for( TInt i=0; i<count; i++ )
+        {
+        CMemSpyEngineDriveEntry* item = iItems[ i ];
+        //
+        if  ( item->DriveNumber() == aDrive )
+            {
+            ret = item;
+            break;
+            }
+        }
+    //
+    return ret;
+    }
+
+
+RFs& CMemSpyEngineDriveList::FsSession()
+    {
+    return iFsSession;
+    }
+
+
+void CMemSpyEngineDriveList::NotifyListChangedL()
+    {
+    if  ( iObserver != NULL )
+        {
+        TRAP_IGNORE( iObserver->HandleDriveListChangedL( *this ) );
+        }
+    }
+
+
+EXPORT_C TInt CMemSpyEngineDriveList::MdcaCount() const
+    {
+    return Count();
+    }
+
+
+EXPORT_C TPtrC CMemSpyEngineDriveList::MdcaPoint( TInt aIndex ) const
+    {
+    const CMemSpyEngineDriveEntry& item = At( aIndex );
+    return TPtrC( item.Caption() );
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+CMemSpyEngineDriveEntry::CMemSpyEngineDriveEntry( CMemSpyEngineDriveList& aList, TDriveNumber aDriveNumber )
+:   CActive( CActive::EPriorityStandard), iList( aList ), iDriveNumber( aDriveNumber ), iDriveUnit( aDriveNumber )
+    {
+    CActiveScheduler::Add( this );
+    }
+
+
+EXPORT_C CMemSpyEngineDriveEntry::~CMemSpyEngineDriveEntry()
+    {
+    Cancel();
+    //
+    delete iCaption;
+    delete iItems;
+    }
+
+
+void CMemSpyEngineDriveEntry::ConstructL()
+    {
+    RunL();
+    }
+
+
+EXPORT_C void CMemSpyEngineDriveEntry::SetObserver( MMemSpyEngineDriveEntryObserver* aObserver )
+    {
+    iObserver = aObserver;
+    }
+
+
+void CMemSpyEngineDriveEntry::RefreshL()
+    {
+    CMemSpyEngineOutputList* items = CMemSpyEngineOutputList::NewL();
+    delete iItems;
+    iItems = items;
+
+    /*
+	RFs13VolumeIOParamEiR18TVolumeIOParamInfo @ 344 NONAME
+	RFs17FileSystemSubTypeEiR6TDes16 @ 345 NONAME
+	RFs18QueryVolumeInfoExtEi22TQueryVolumeInfoExtCmdR5TDes8 @ 346 NONAME
+    */
+    const TInt err1 = FsSession().Drive( iDriveInfo, iDriveNumber );
+    const TInt err2 = FsSession().Volume( iVolumeInfo, iDriveNumber );
+    if  ( err1 || err2 )
+        {
+        _LIT( KUnavailable, "Unavailable");
+        iItems->AddItemL( KUnavailable );
+
+        // Mostly empty caption
+        CreateCaptionL( KNullDesC, KNullDesC );
+        }
+    else
+        {
+        // Literal constants
+        TBuf<KMaxFileName * 2> temp;
+        TBuf<KMaxFileName * 2> item;
+
+        AddStandardFieldsL();
+
+        _LIT( KEntry2a, "Media Type");
+        TBuf<20> mediaType;
+        GetMediaTypeText( iDriveInfo.iType, mediaType );
+        iItems->AddItemL( KEntry2a, mediaType );
+
+        _LIT( KEntry2b, "Battery Status");
+        GetBatteryState( iDriveInfo.iBattery, temp );
+        iItems->AddItemL( KEntry2b, temp );
+
+        // Now have enough data to create caption
+        CreateCaptionL( iVolumeInfo.iName, mediaType );
+        
+        CreateDriveAttributesL( item );
+        CreateMediaAttributesL( item );
+
+        _LIT( KEntry3a, "Volume Name");
+        if  ( iVolumeInfo.iName.Length() )
+            {
+            iItems->AddItemL( KEntry3a, iVolumeInfo.iName );
+            }
+        else
+            {
+            iItems->AddItemL( KEntry3a, KMemSpyVolumeLabelNotSet );
+            }
+
+        _LIT( KEntry3, "Volume UID");
+        iItems->AddItemHexL( KEntry3, iVolumeInfo.iUniqueID );
+
+        _LIT( KEntry4, "Volume Size");
+        temp = MemSpyEngineUtils::FormatSizeText( iVolumeInfo.iSize );
+        iItems->AddItemL( KEntry4, temp );
+
+        _LIT( KEntry5, "Volume Free");
+        temp = MemSpyEngineUtils::FormatSizeText( iVolumeInfo.iFree );
+        iItems->AddItemL( KEntry5, temp );
+
+        TMediaSerialNumber serialNum;
+        if  ( FsSession().GetMediaSerialNumber( serialNum, iDriveNumber ) == KErrNone )
+            {
+            _LIT( KEntry6, "Serial Number");
+            TBuf<KMaxSerialNumLength> serialNumUnicode;
+            serialNumUnicode.Copy( serialNum );
+            iItems->AddItemL( KEntry6, serialNumUnicode );
+            }
+
+        if  ( FsSession().FileSystemName( temp, iDriveNumber ) == KErrNone )
+            {
+            _LIT( KEntry7, "File System");
+            iItems->AddItemL( KEntry7, temp );
+            }
+        }
+    }
+
+
+CMemSpyEngineDriveEntry* CMemSpyEngineDriveEntry::NewLC( CMemSpyEngineDriveList& aList, TDriveNumber aDriveNumber )
+    {
+    CMemSpyEngineDriveEntry* self = new(ELeave) CMemSpyEngineDriveEntry( aList, aDriveNumber );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    return self;
+    }
+
+
+void CMemSpyEngineDriveEntry::CreateDriveAttributesL( TDes& aItemBuf )
+    {
+    TInt driveAttribIndex = 0;
+    _LIT( KEntryText, "Drive Attribute %d");
+
+    if  ( iDriveInfo.iDriveAtt & KDriveAttLocal )
+        {
+        _LIT( KAttribName, "Local" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iDriveAtt & KDriveAttRom )
+        {
+        _LIT( KAttribName, "ROM" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iDriveAtt & KDriveAttRedirected )
+        {
+        _LIT( KAttribName, "Redirected" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iDriveAtt & KDriveAttSubsted )
+        {
+        _LIT( KAttribName, "Substed" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iDriveAtt & KDriveAttInternal )
+        {
+        _LIT( KAttribName, "Internal" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iDriveAtt & KDriveAttRemovable )
+        {
+        _LIT( KAttribName, "Removable" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iDriveAtt & KDriveAttRemote )
+        {
+        _LIT( KAttribName, "Remote" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iDriveAtt & KDriveAttTransaction )
+        {
+        _LIT( KAttribName, "Transaction" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iDriveAtt & KMemSpyDriveAttPageable )
+        {
+        _LIT( KAttribName, "Pageable" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iDriveAtt & KDriveAttRemovable )
+        {
+        _LIT( KAttribName, "Removable" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    }
+
+
+void CMemSpyEngineDriveEntry::CreateMediaAttributesL( TDes& aItemBuf )
+    {
+    TInt driveAttribIndex = 0;
+    _LIT( KEntryText, "Media Attribute %d");
+
+    if  ( iDriveInfo.iMediaAtt & KMediaAttVariableSize )
+        {
+        _LIT( KAttribName, "Variable Size" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iMediaAtt & KMediaAttDualDensity )
+        {
+        _LIT( KAttribName, "Dual Density" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iMediaAtt & KMediaAttFormattable )
+        {
+        _LIT( KAttribName, "Formattable" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iMediaAtt & KMediaAttWriteProtected )
+        {
+        _LIT( KAttribName, "Write Protected" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iMediaAtt & KMediaAttLockable )
+        {
+        _LIT( KAttribName, "Lockable" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iMediaAtt & KMediaAttLocked )
+        {
+        _LIT( KAttribName, "Locked" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iMediaAtt & KMediaAttHasPassword )
+        {
+        _LIT( KAttribName, "Has Password" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iMediaAtt & KMediaAttReadWhileWrite )
+        {
+        _LIT( KAttribName, "Read-while-Write" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iMediaAtt & KMediaAttDeleteNotify )
+        {
+        _LIT( KAttribName, "Delete Notify" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    if  ( iDriveInfo.iMediaAtt & KMemSpyMediaAttPageable )
+        {
+        _LIT( KAttribName, "Pageable" );
+        aItemBuf.Format( KEntryText, ++driveAttribIndex );
+        iItems->AddItemL( aItemBuf, KAttribName );
+        }
+    }
+
+
+void CMemSpyEngineDriveEntry::AddStandardFieldsL()
+    {
+    _LIT( KEntry1, "Unit Name");
+    const TDriveName driveUnitName = iDriveUnit.Name();
+    iItems->AddItemL( KEntry1, driveUnitName );
+
+    _LIT( KEntry2, "Unit Number");
+    TBuf<30> temp;
+    CMemSpyEngineHelperFileSystem::GetDriveNumberText( iDriveNumber, temp );
+    iItems->AddItemL( KEntry2, temp );
+
+    const TDriveNumber sysDrive = GetSystemDrive();
+    if  ( sysDrive == iDriveNumber )
+        {
+        _LIT( KEntry3, "System Drive");
+        iItems->AddItemYesNoL( KEntry3, ETrue );
+        }
+    }
+
+
+void CMemSpyEngineDriveEntry::CreateCaptionL( const TDesC& aVolumeName, const TDesC& aMediaType )
+    {
+    TBuf<256 * 2> caption;
+
+    // Always include drive unit name
+    const TDriveName driveUnitName = iDriveUnit.Name();
+    caption.AppendFormat( _L("\t%S"), &driveUnitName );
+
+    // If we have a volume name, then include that too
+    if  ( aVolumeName.Length() )
+        {
+        caption.AppendFormat( _L(" [%S]"), &aVolumeName );
+        }
+    
+    // New line
+    caption.Append( _L("\t\t") );
+
+    // Include media type if known, or unknown otherwise
+    if  ( aMediaType.Length() )
+        {
+        caption.Append( aMediaType );
+        }
+    else
+        {
+        _LIT( KUnknownMediaType, "Unknown" );
+        caption.Append( KUnknownMediaType );
+        }
+
+    HBufC* finalCaption = caption.AllocL();
+    delete iCaption;
+    iCaption = finalCaption;
+    }
+
+void CMemSpyEngineDriveEntry::GetMediaTypeText( TMediaType aType, TDes& aText )
+    {
+    switch( aType )
+        {
+    case EMediaNotPresent:
+        aText.Copy( _L("Not Present") );
+        break;
+    case EMediaFloppy:
+        aText.Copy( _L("Floppy") );
+        break;
+    case EMediaHardDisk:
+        aText.Copy( _L("Hard Disk") );
+        break;
+    case EMediaCdRom:
+        aText.Copy( _L("CD-ROM") );
+        break;
+    case EMediaRam:
+        aText.Copy( _L("RAM") );
+        break;
+    case EMediaFlash:
+        aText.Copy( _L("Flash") );
+        break;
+    case EMediaRom:
+        aText.Copy( _L("ROM") );
+        break;
+    case EMediaRemote:
+        aText.Copy( _L("Remote") );
+        break;
+    case EMediaNANDFlash:
+        aText.Copy( _L("NAND Flash") );
+        break;
+    default:
+    case EMediaUnknown:
+        aText.Copy( _L("Unknown") );
+        break;
+        }
+    }
+
+
+void CMemSpyEngineDriveEntry::GetBatteryState( TBatteryState aBatteryState, TDes& aText )
+    {
+    switch( aBatteryState )
+        {
+    case EBatNotSupported:
+        aText.Copy( _L("Not Supported") );
+        break;
+    case EBatGood:
+        aText.Copy( _L("Good") );
+        break;
+    case EBatLow:
+        aText.Copy( _L("Low") );
+        break;
+    default:
+        aText.Copy( _L("Unknown") );
+        break;
+        }
+    }
+
+
+TDriveNumber CMemSpyEngineDriveEntry::GetSystemDrive()
+    {
+    return CMemSpyEngineHelperFileSystem::GetSystemDrive();
+    }
+
+
+EXPORT_C TInt CMemSpyEngineDriveEntry::MdcaCount() const
+    {
+    return iItems->Count();
+    }
+
+
+EXPORT_C TPtrC CMemSpyEngineDriveEntry::MdcaPoint( TInt aIndex ) const
+    {
+    return iItems->MdcaPoint( aIndex );
+    }
+
+
+void CMemSpyEngineDriveEntry::RunL()
+    {
+    FsSession().NotifyChange( ENotifyDisk, iStatus );
+    SetActive();
+    //
+    TRAP_IGNORE( RefreshL() );
+    //
+    if ( iObserver != NULL )
+        {
+        TRAP_IGNORE( iObserver->HandleDriveEntryChangedL( *this ) );
+        }
+    }
+
+
+void CMemSpyEngineDriveEntry::DoCancel()
+    {
+    FsSession().NotifyChangeCancel();
+    }
+
+
+RFs& CMemSpyEngineDriveEntry::FsSession()
+    {
+    return iList.FsSession();
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+CMemSpyEngineOpenFileListEntry::CMemSpyEngineOpenFileListEntry()
+    {
+    }
+
+
+CMemSpyEngineOpenFileListEntry::~CMemSpyEngineOpenFileListEntry()
+    {
+    delete iFileName;
+    }
+
+
+void CMemSpyEngineOpenFileListEntry::ConstructL( const TEntry& aEntry )
+    {
+    iFileName = aEntry.iName.AllocL();
+    iAtt = aEntry.iAtt;
+    iType = aEntry.iType;
+    iSize = aEntry.iSize;
+    iModified = aEntry.iModified;
+    }
+
+
+CMemSpyEngineOpenFileListEntry* CMemSpyEngineOpenFileListEntry::NewLC( const TEntry& aEntry )
+    {
+    CMemSpyEngineOpenFileListEntry* self = new(ELeave) CMemSpyEngineOpenFileListEntry();
+    CleanupStack::PushL( self );
+    self->ConstructL( aEntry );
+    return self;
+    }
+
+
+EXPORT_C const TDesC& CMemSpyEngineOpenFileListEntry::FileName() const
+    {
+    return *iFileName;
+    }
+
+
+EXPORT_C TInt CMemSpyEngineOpenFileListEntry::Size() const
+    {
+    return iSize;
+    }
+
+
+TInt CMemSpyEngineOpenFileListEntry::UniqueFileId() const
+    {
+    return iUniqueFileIdentifier;
+    }
+
+
+void CMemSpyEngineOpenFileListEntry::SetUniqueFileId( TInt aValue )
+    {
+    iUniqueFileIdentifier = aValue;
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+CMemSpyEngineOpenFileListForThread::CMemSpyEngineOpenFileListForThread( const TThreadId& aThreadId, const TProcessId& aProcessId )
+:   iThreadId( aThreadId ), iProcessId( aProcessId )
+    {
+    }
+
+
+CMemSpyEngineOpenFileListForThread::~CMemSpyEngineOpenFileListForThread()
+    {
+    iItems.ResetAndDestroy();
+    iItems.Close();
+    delete iThreadName;
+    }
+
+
+void CMemSpyEngineOpenFileListForThread::ConstructL( const TDesC& aThreadName, const CFileList& aList )
+    {
+    iThreadName = aThreadName.AllocL();
+
+    // Create fs entries
+    const TInt entryCount = aList.Count();
+    for(TInt i=0; i<entryCount; i++)
+        {
+        const TEntry& fsEntry = (aList)[ i ];
+        //
+        CMemSpyEngineOpenFileListEntry* entry = CMemSpyEngineOpenFileListEntry::NewLC( fsEntry );
+        AddL( entry );
+        CleanupStack::Pop( entry );
+        }
+    }
+
+
+CMemSpyEngineOpenFileListForThread* CMemSpyEngineOpenFileListForThread::NewLC( const TDesC& aThreadName, const TThreadId& aThreadId, const TProcessId& aProcessId, const CFileList& aList )
+    {
+    CMemSpyEngineOpenFileListForThread* self = new(ELeave) CMemSpyEngineOpenFileListForThread( aThreadId, aProcessId );
+    CleanupStack::PushL( self );
+    self->ConstructL( aThreadName, aList );
+    return self;
+    }
+
+
+EXPORT_C const TDesC& CMemSpyEngineOpenFileListForThread::ThreadName() const
+    {
+    return *iThreadName;
+    }
+
+
+EXPORT_C const TThreadId& CMemSpyEngineOpenFileListForThread::ThreadId() const
+    {
+    return iThreadId;
+    }
+
+
+EXPORT_C const TProcessId& CMemSpyEngineOpenFileListForThread::ProcessId() const
+    {
+    return iProcessId;
+    }
+
+
+EXPORT_C TInt CMemSpyEngineOpenFileListForThread::Count() const
+    {
+    return iItems.Count();
+    }
+
+
+EXPORT_C const CMemSpyEngineOpenFileListEntry& CMemSpyEngineOpenFileListForThread::At( TInt aIndex ) const
+    {
+    return *iItems[ aIndex ];
+    }
+ 
+
+void CMemSpyEngineOpenFileListForThread::AddL( CMemSpyEngineOpenFileListEntry* aEntry )
+    {
+    // Ensure we increment the unique filename counter if adding an entry where the same filename
+    // already is registered with the list.
+    CMemSpyEngineOpenFileListEntry* existingEntry = EntryByFileName( aEntry->FileName() );
+    if  ( existingEntry )
+        {
+        // EntryByFileName() always returns the most recent entry with the same name. The list
+        // itself is not sorted as entries are always appended to it.
+        const TInt lastUID = existingEntry->UniqueFileId();
+#ifdef _DEBUG
+        RDebug::Print( _L("CMemSpyEngineOpenFileListForThread::AddL() - searched for %S and found existing entry with UID: %d"), &aEntry->FileName(), lastUID );
+#endif
+
+        aEntry->SetUniqueFileId( lastUID + 1 );
+        }
+
+    iItems.AppendL( aEntry );
+    }
+
+
+CMemSpyEngineOpenFileListEntry* CMemSpyEngineOpenFileListForThread::EntryByFileName( const TDesC& aFileName )
+    {
+    CMemSpyEngineOpenFileListEntry* ret = NULL;
+    //
+    const TInt count = iItems.Count();
+    for( TInt i=count-1; i>=0; i-- )
+        {
+        CMemSpyEngineOpenFileListEntry* item = iItems[ i ];
+        if  ( item->FileName().CompareF( aFileName ) == 0 )
+            {
+            ret = item;
+            break;
+            }
+        }
+    //
+    return ret;
+    }
+
+
+
+
+
+
+
+
+
+
+CMemSpyEngineOpenFileList::CMemSpyEngineOpenFileList()
+    {
+    }
+
+
+EXPORT_C CMemSpyEngineOpenFileList::~CMemSpyEngineOpenFileList()
+    {
+    iItems.ResetAndDestroy();
+    iItems.Close();
+    }
+
+
+void CMemSpyEngineOpenFileList::ConstructL( CMemSpyEngine& aEngine )
+    {
+    _LIT( KUnknownThread, "Unknown Thread" );
+    TFullName threadName;
+    TOpenFileScan scanner( aEngine.FsSession() );
+    //
+    CFileList* list = NULL;
+    scanner.NextL( list );
+    while( list != NULL )
+        {
+        CleanupStack::PushL( list );
+
+        // Reset name
+        threadName = KUnknownThread;
+        
+        // Try to get real thread name
+        TProcessId procId;
+        RThread thread;
+        if  ( aEngine.Driver().OpenThread( scanner.ThreadId(), thread ) == KErrNone )
+            {
+            RProcess process;
+            if ( thread.Process( process ) == KErrNone )
+                {
+                procId = process.Id();
+                process.Close();
+                }
+            //
+            thread.FullName( threadName );
+            thread.Close();
+            }
+
+        // Create thread entry
+        CMemSpyEngineOpenFileListForThread* threadEntry = CMemSpyEngineOpenFileListForThread::NewLC( threadName, scanner.ThreadId(), procId, *list );
+        iItems.AppendL( threadEntry );
+        CleanupStack::Pop( threadEntry );
+
+        // Destroy list and move on to next thread.
+        CleanupStack::PopAndDestroy( list );
+        list = NULL;
+        scanner.NextL( list );
+        }
+    }
+
+
+CMemSpyEngineOpenFileList* CMemSpyEngineOpenFileList::NewLC( CMemSpyEngine& aEngine )
+    {
+    CMemSpyEngineOpenFileList* self = new(ELeave) CMemSpyEngineOpenFileList();
+    CleanupStack::PushL( self );
+    self->ConstructL( aEngine );
+    return self;
+    }
+
+
+EXPORT_C TInt CMemSpyEngineOpenFileList::Count() const
+    {
+    return iItems.Count();
+    }
+
+
+EXPORT_C const CMemSpyEngineOpenFileListForThread& CMemSpyEngineOpenFileList::At( TInt aIndex ) const
+    {
+    return *iItems[ aIndex ];
+    }
+