/*

* 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 "MemSpyViewKernelHeap.h"

// Engine includes

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyengineobjectprocess.h>

#include <memspy/engine/memspyengineobjectthread.h>

#include <memspy/engine/memspyengineobjectcontainer.h>

#include <memspy/engine/memspyengineobjectthreadinfoobjects.h>

#include <memspy/engine/memspyengineobjectthreadinfocontainer.h>

#include <memspy/engine/memspyenginehelperheap.h>

#include <memspy/engine/memspyengineoutputlist.h>

#include <memspysession.h>

#include <memspy/api/memspyapiheap.h>

// User includes

#include "MemSpyUiUtils.h"

#include "MemSpyViewKernel.h"

#include "MemSpyContainerObserver.h"

// Constants

const TInt KMemSpyBufferSize = 20;

// Literal constants

_LIT(KMemSpyHexFormat, "0x%08x");

_LIT(KMemSpyUnsignedFormat, "%u");

_LIT(KMemSpyDecFormat, "%d");

_LIT(KMemSpyLongFormat, "%Ld");

_LIT(KMemSpyCaptionYes, "Yes");

_LIT(KMemSpyCaptionNo, "No");

CMemSpyViewKernelHeap::CMemSpyViewKernelHeap( RMemSpySession& aSession, MMemSpyViewObserver& aObserver ) //cigasto: remember to uncomment from MMP!

:   CMemSpyViewBase( aSession, aObserver )

    {

    }

CMemSpyViewKernelHeap::~CMemSpyViewKernelHeap()

    {

    }

void CMemSpyViewKernelHeap::ConstructL( const TRect& aRect, CCoeControl& aContainer, TAny* aSelectionRune )

    {

    _LIT( KTitle, "Kernel Heap" );

    SetTitleL( KTitle );

    //

    CMemSpyViewBase::ConstructL( aRect, aContainer, aSelectionRune );

    }

void CMemSpyViewKernelHeap::RefreshL()

    {

    SetListBoxModelL();

    CMemSpyViewBase::RefreshL();

    }

TMemSpyViewType CMemSpyViewKernelHeap::ViewType() const

    {

    return EMemSpyViewTypeKernelHeap;

    }

CMemSpyViewBase* CMemSpyViewKernelHeap::PrepareParentViewL()

    {

    CMemSpyViewKernel* parent = new(ELeave) CMemSpyViewKernel( iMemSpySession, iObserver );

    CleanupStack::PushL( parent );

    parent->ConstructL( Rect(), *Parent(), (TAny*) ViewType() );

    CleanupStack::Pop( parent );

    return parent;

    }

CMemSpyViewBase* CMemSpyViewKernelHeap::PrepareChildViewL()

    {	

    CMemSpyViewBase* child = NULL;

    return child;    

    }

void CMemSpyViewKernelHeap::SetListBoxModelL()

    {	

	CMemSpyApiHeap* iHeap;

	iHeap = iMemSpySession.GetHeap( );

	model = FormatModel( iHeap );	

	CAknSettingStyleListBox* listbox = static_cast< CAknSettingStyleListBox* >( iListBox );

	listbox->Model()->SetItemTextArray( model );

	listbox->Model()->SetOwnershipType( ELbmOwnsItemArray );	

	/*

	// Get list contents

	TMemSpyHeapInfo heapInfo;

	iEngine.HelperHeap().GetHeapInfoKernelL( heapInfo );

	CMemSpyEngineOutputList* list = iEngine.HelperHeap().NewHeapSummaryShortLC( heapInfo );

	// Set up list box

	CAknSettingStyleListBox* listbox = static_cast< CAknSettingStyleListBox* >( iListBox );

	listbox->Model()->SetItemTextArray( list );

	listbox->Model()->SetOwnershipType( ELbmOwnsItemArray );

	CleanupStack::Pop( list );

	*/

	}

TBool CMemSpyViewKernelHeap::HandleCommandL( TInt aCommand )

    {

    TBool handled = ETrue;

    //

    switch ( aCommand )

        {

    case EMemSpyCmdKernelHeapDump:

        OnCmdDumpKernelHeapL();

        break;

    default:

        handled = CMemSpyViewBase::HandleCommandL( aCommand );

        break;

        }

    //

    return handled;

    }

void CMemSpyViewKernelHeap::OnCmdDumpKernelHeapL()

    }

//CDesCArrayFlat* CMemSpyViewKernelHeap::FormatModel( RArray<CMemSpyApiHeap*> &aHeap )

CDesCArrayFlat* CMemSpyViewKernelHeap::FormatModel( CMemSpyApiHeap* aHeap )

	{

	CDesCArrayFlat* ret = new (ELeave) CDesC16ArrayFlat( 2 );

	 _LIT( KItem0, "Heap type" );		   	  

	 _LIT( KItem1, "Heap size" );	  

	 _LIT( KItem8b, "Heap base address" );	        	       

	 _LIT( KItem1b, "Shared" );	        

	 _LIT( KItem2, "Chunk size" );

	 _LIT( KItem3, "Alloc. count" );

	 _LIT( KItem4, "Free. count" );

	 _LIT( KItem5, "Biggest alloc." );

	 _LIT( KItem6, "Biggest free" );

	 _LIT( KItem6a, "Total alloc." );

	 _LIT( KItem6b, "Total free" );

	 _LIT( KItem7, "Slack free space" );

	 _LIT( KItem8a, "Fragmentation" );

	 _LIT( KItem13, "Header size (A)" );

	 _LIT( KItem14, "Header size (F)" );

	 _LIT( KItem9a, "Overhead (alloc)" );

	 _LIT( KItem9b, "Overhead (free)" );

	 _LIT( KItem9c, "Overhead (total)" );

	 _LIT( KItem9d, "Overhead" );

	 _LIT( KItem10, "Min. length" );

	 _LIT( KItem11, "Max. length" );

	 _LIT( KItem12, "Debug Allocator Library" );

	iItem = FormatItem( KItem0, aHeap->Type() );

	TPtr pItem( iItem->Des() );

	ret->AppendL( pItem );

	pItem.Zero();	

	iItem = FormatItem( KItem1, aHeap->Size() );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();	

	TUint address( aHeap->BaseAddress() );	

	iItem = FormatItem( KItem8b, address );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	if(aHeap->Shared()) //Yes / No value formatting		

		iItem = FormatItem( KItem1b, KMemSpyCaptionYes );		

	else		

		iItem = FormatItem( KItem1b, KMemSpyCaptionNo );	

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	iItem = FormatItem( KItem2, aHeap->ChunkSize() );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	iItem = FormatItem( KItem3, aHeap->AllocationsCount() );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	iItem = FormatItem( KItem4, aHeap->FreeCount() );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	iItem = FormatItem( KItem5, aHeap->BiggestAllocation() );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	iItem = FormatItem( KItem6, aHeap->BiggestFree() );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	iItem = FormatItem( KItem6a, aHeap->TotalAllocations() );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	iItem = FormatItem( KItem6b, aHeap->TotalFree() );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	iItem = FormatItem( KItem7, aHeap->SlackFreeSpace() );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	TReal iOneHundred( aHeap->Size() );

	TReal iValue( aHeap->Fragmentation() );	

	iItem = FormatPercentageItem( KItem8a, iOneHundred, iValue );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	iItem = FormatItem( KItem13, aHeap->HeaderSizeA() );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	iItem = FormatItem( KItem14, aHeap->HeaderSizeF() );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	iItem = FormatItem( KItem9a, aHeap->AllocationOverhead() );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	iItem = FormatItem( KItem9b, aHeap->FreeOverhead() );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	iItem = FormatItem( KItem9c, aHeap->TotalOverhead() );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	TReal iOverhead( aHeap->Overhead() );	

	iItem = FormatPercentageItem( KItem9d, iOneHundred, iOverhead );	

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	iItem = FormatItem( KItem10, aHeap->MinLength() );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	iItem = FormatItem( KItem11, aHeap->MaxLength() );

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	if( aHeap->DebugAllocatorLibrary() )		

		iItem = FormatItem( KItem12, KMemSpyCaptionYes );		

	else

		iItem = FormatItem( KItem12, KMemSpyCaptionNo );	

	pItem = iItem->Des();

	ret->AppendL( pItem );

	pItem.Zero();

	return ret;

	}

HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, const TDesC& aValue )

	{

	TPtr pRetBuf( retBuf->Des() );

	pRetBuf.Zero();

	pRetBuf.Append( _L("\t") );

	pRetBuf.Append( aCaption );

	pRetBuf.Append( _L("\t\t") );

	pRetBuf.Append( aValue );

	return retBuf;

	}

HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, TInt aValue )

	{

	TPtr pRetBuf( retBuf->Des() );

	pRetBuf.Zero();

	TBuf<KMemSpyBufferSize> val;

    val.Format( KMemSpyDecFormat, aValue );

    pRetBuf.Append( _L("\t") );

    pRetBuf.Append( aCaption );

    pRetBuf.Append( _L("\t\t") );

    pRetBuf.Append( val );    

	return retBuf;

	}

HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, TUint aValue )

	{

	TPtr pRetBuf( retBuf->Des() );

	pRetBuf.Zero();

	TBuf<KMemSpyBufferSize> val;

    //val.Format( KMemSpyDecFormat, aValue );

	val.Format( KMemSpyHexFormat, aValue );

    pRetBuf.Append( _L("\t") );

    pRetBuf.Append( aCaption );

    pRetBuf.Append( _L("\t\t") );

    pRetBuf.Append( val );    

	return retBuf;	

	}

HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, const TInt64& aValue )

	{

	TPtr pRetBuf( retBuf->Des() );

	pRetBuf.Zero();

	TBuf<KMemSpyBufferSize> val;

	val.Format( KMemSpyLongFormat, aValue );

	pRetBuf.Append( _L("\t") );

	pRetBuf.Append( aCaption );

	pRetBuf.Append( _L("\t\t") );

	pRetBuf.Append( val );    

	return retBuf;	

	}

HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, TAny* aValue )

	{

	TPtr pRetBuf( retBuf->Des() );

	pRetBuf.Zero();

	TBuf<KMemSpyBufferSize> val;

	val.Format( KMemSpyHexFormat, aValue );

	pRetBuf.Append( _L("\t") );

	pRetBuf.Append( aCaption );

	pRetBuf.Append( _L("\t\t") );

	pRetBuf.Append( val );    

	return retBuf;	

	}

HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, TUint* aValue )

	{

	TPtr pRetBuf( retBuf->Des() );

	pRetBuf.Zero();

	TBuf<KMemSpyBufferSize> val;

	val.Format( KMemSpyHexFormat, aValue );

	pRetBuf.Append( _L("\t") );

	pRetBuf.Append( aCaption );

	pRetBuf.Append( _L("\t\t") );

	pRetBuf.Append( val );    

	return retBuf;	

	}

HBufC* CMemSpyViewKernelHeap::FormatItem( const TDesC& aCaption, TUint8* aValue )

	{

	TPtr pRetBuf( retBuf->Des() );

	pRetBuf.Zero();

	TBuf<KMemSpyBufferSize> val;

	val.Format( KMemSpyHexFormat, aValue );

	pRetBuf.Append( _L("\t") );

	pRetBuf.Append( aCaption );

	pRetBuf.Append( _L("\t\t") );

	pRetBuf.Append( val );    

	return retBuf;	

	}

HBufC* CMemSpyViewKernelHeap::FormatPercentageItem( const TDesC& aCaption, TReal aOneHundredPercentValue, TReal aValue )

	{

	TPtr pRetBuf( retBuf->Des() );

	pRetBuf.Zero();

    const TReal value = (TInt) (( aValue / aOneHundredPercentValue) * 100.0); // percentage value calculation    

    _LIT(KPercentFormat, "%3.2f %%");

    TMemSpyPercentText val;

    val.Format( KPercentFormat, value );

	pRetBuf.Append( _L("\t") );

	pRetBuf.Append( aCaption );

	pRetBuf.Append( _L("\t\t") );

	pRetBuf.Append( val );    

	return retBuf;

	}