/*

* 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:

*

*/

#ifndef MEMSPYENGINEHELPERFBSERV_H

#define MEMSPYENGINEHELPERFBSERV_H

// System includes

#include <e32base.h>

#include <badesca.h>

#include <fbs.h>

#include <bitmap.h>

// Classes referenced

class CMemSpyEngine;

class CMemSpyThread;

class TMemSpyDriverChunkInfo;

class TMemSpyEngineFBServBitmapInfo;

// Constants

const TInt KMemSpyEngineDefaultBitmapCreationBatchSize = 4; // Create 4 bitmaps (asynchronously) at a time

NONSHARABLE_CLASS( CMemSpyEngineHelperFbServ ) : public CBase

    {

public: // Construct/destruct

    static CMemSpyEngineHelperFbServ* NewL( CMemSpyEngine& aEngine );

    ~CMemSpyEngineHelperFbServ();

private: // Internal construction

    CMemSpyEngineHelperFbServ( CMemSpyEngine& aEngine );

    void ConstructL();

public: // API

    IMPORT_C void GetArrayOfBitmapHandlesL( RArray<TInt>& aHandles );

public: // API - but not exported

    void GetArrayOfBitmapHandlesL( RArray<TInt>& aHandles, TInt& aBitmapConCount, TInt& aFontConCount );

    static TBool IsLargeBitmapChunk( const TMemSpyDriverChunkInfo& aChunkInfo );

    static TBool IsSharedBitmapChunk( const TMemSpyDriverChunkInfo& aChunkInfo );

    static void GetBitmapInfoL( TInt aHandle, TMemSpyEngineFBServBitmapInfo& aInfo );

    static CFbsBitmap* GetBitmapInfoLC( TInt aHandle, TMemSpyEngineFBServBitmapInfo& aInfo );

private: // Internal structures

    class CBitmapObject : public CObject

        {

    public:

        CBitmapObject* iThisPointer;

    public:

        CBase* iTop; // actually CFbTop*

        CBitwiseBitmap* iAddressPointer;

        TInt iHandle;

        CBitmapObject* iCleanBitmap;

        };

private: // Internal methods

    CMemSpyThread& IdentifyFbServThreadL();

    HBufC8* LocateCFbTopHeapCellDataLC( CMemSpyThread& aFbServThread, TAny*& aCellAddress );

    HBufC8* LocateBitmapArrayHeapCellDataLC( TAny*& aArrayCellAddress, TInt aArrayAllocCount );

    void ReadCObjectConInfoL( TAny* aCellAddress, RArray<TAny*>& aContainerObjects, TInt& aCount, TInt& aAllocated );

    static void ParseCellDataAndExtractHandlesL( const TDesC8& aData, RArray<TInt>& aHandles, TInt aArrayEntryCount );

    static TUint OffsetToCObjectConBitmapCon();

    static TUint OffsetToCObjectConFontCon();

    static TUint OffsetToBitmapHandleArray();

    CBitmapObject* GetBitmapObjectLC( TAny* aAddress );

private: // Data members

    CMemSpyEngine& iEngine;

    };

NONSHARABLE_CLASS( CMemSpyEngineFbServBitmap ) : public CDesCArrayFlat

    {

public: // Construct/destruct

    IMPORT_C static CMemSpyEngineFbServBitmap* NewLC( TInt aHandle );

    IMPORT_C ~CMemSpyEngineFbServBitmap();

private: // Internal construction

    CMemSpyEngineFbServBitmap();

    void ConstructL( TInt aHandle );

public: // API

    TInt BitmapSizeInBytes() const;

    IMPORT_C const TDesC& Caption() const;

    IMPORT_C CFbsBitmap& Bitmap();

    IMPORT_C const CFbsBitmap& Bitmap() const;

    IMPORT_C TInt Handle() const;

    IMPORT_C void OutputDataL( CMemSpyEngine& aEngine ) const;

    IMPORT_C static void OutputDataColumnsL( CMemSpyEngine& aEngine );

    IMPORT_C void GetExportableFileNameL( TDes& aAppendName ) const;

public: // But not exported

    static void GetExportableFileNameL( const TMemSpyEngineFBServBitmapInfo& aInfo, TDes& aAppendName );

private: // Internal

    void PrepareItemsL();

private: 

    static void GetFileCompressionTypeAsString( TBitmapfileCompression aType, TDes& aString );

private: // Data members

    CFbsBitmap* iBitmap;

    HBufC* iCaption;

    };

class MMemSpyEngineFbSerbBitmapArrayObserver

    {

public:

    enum TEvent

        {

        EBitmapItemsCreated = 0,

        EBitmapArrayConstructionComplete

        };

public: // From MMemSpyEngineFbSerbBitmapArrayObserver

    virtual void HandleFbServBitmapArrayEventL( TEvent aEvent ) = 0;

    };

NONSHARABLE_CLASS( CMemSpyEngineFbServBitmapArray ) : public CActive, public MDesCArray

    {

public: // Construct/destruct

    IMPORT_C static CMemSpyEngineFbServBitmapArray* NewL( const RArray<TInt>& aBitmapHandles );

    IMPORT_C static CMemSpyEngineFbServBitmapArray* NewL( TInt aPriority, const RArray<TInt>& aBitmapHandles, MMemSpyEngineFbSerbBitmapArrayObserver& aObserver, TInt aGranularity = KMemSpyEngineDefaultBitmapCreationBatchSize );

    IMPORT_C ~CMemSpyEngineFbServBitmapArray();

private: // Internal construction

    CMemSpyEngineFbServBitmapArray( const RArray<TInt>& aBitmapHandles );

    CMemSpyEngineFbServBitmapArray( TInt aPriority, const RArray<TInt>& aBitmapHandles, MMemSpyEngineFbSerbBitmapArrayObserver& aObserver, TInt aGranularity );

    void ConstructL();

public: // API

    IMPORT_C TInt Count() const;

    IMPORT_C CMemSpyEngineFbServBitmap& At( TInt aIndex );

    IMPORT_C const CMemSpyEngineFbServBitmap& At( TInt aIndex ) const;

    IMPORT_C CMemSpyEngineFbServBitmap& BitmapByHandleL( TInt aHandle );

    IMPORT_C TInt BitmapIndexByHandle( TInt aHandle ) const;

public: // From MDesCArray

    IMPORT_C TInt MdcaCount() const;

    IMPORT_C TPtrC MdcaPoint( TInt aIndex ) const;

private: // From CActive

    void RunL();

    void DoCancel();

    TInt RunError( TInt aError );

private: // Internal

    void CompleteSelf();

    void CreateBitmapL( TInt aHandle );

    void SortBySizeL();

    static TInt CompareBySize( const CMemSpyEngineFbServBitmap& aLeft, const CMemSpyEngineFbServBitmap& aRight );

private: // Data members

    const RArray<TInt>& iBitmapHandles;

    MMemSpyEngineFbSerbBitmapArrayObserver* iObserver;

    const TInt iGranularity;

    // Transient

    TInt iIndex;

    // Owned

    RPointerArray< CMemSpyEngineFbServBitmap > iBitmaps;

    };

class TMemSpyEngineFBServBitmapInfo

    {

public:

    inline TMemSpyEngineFBServBitmapInfo()

        : iHandle( 0 ), iSizeInPixels( 0, 0 ), iCompressionType( ENoBitmapCompression ),

        iSizeInBytes( 0 ), iDisplayMode( 0 ), iBitsPerPixel( 0 ), iFlags( TMemSpyEngineFBServBitmapInfo::EFlagsNone )

        {}

public: // Enumerations

    enum TFlags

        {

        EFlagsNone = 0,

        EFlagsIsRomBitmap = 1,

        EFlagsIsMonochrome = 2,

        EFlagsIsLarge = 4,

        EFlagsIsCompressedInRam = 8,

        };

public: // Data members

    TInt iHandle;

    TSize iSizeInPixels;

    TBitmapfileCompression iCompressionType;

    TInt iSizeInBytes;

    TInt8 iDisplayMode;

    TInt8 iBitsPerPixel;

    TUint16 iFlags;

    TInt iColor;

    };

#endif