/*

* 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/memspyengineobjectthreadinfoobjects.h>

// System includes

#include <f32file.h>

#include <hal.h>

#include <kernel/arm/arm_types.h>

#include <memspy/driver/memspydriverclient.h>

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyengineutils.h>

#include <memspy/engine/memspyengineoutputlist.h>

#include <memspy/engine/memspyenginehelpercodesegment.h>

#include <memspy/engine/memspyenginehelperactiveobject.h>

#include <memspy/engine/memspyenginehelperchunk.h>

#include <memspy/engine/memspyenginehelperheap.h>

#include <memspy/engine/memspyenginehelperprocess.h>

#include <memspy/engine/memspyengineobjectprocess.h>

#include <memspy/engine/memspyengineobjectthread.h>

#include <memspy/engine/memspyengineobjectthreadinfocontainer.h>

#include <memspy/engine/memspyengineoutputsink.h>

// User includes

#include "MemSpyEngineOutputListItem.h"

// Constants

const TInt KMemSpyNumericFormatBufferSize = 20;

// Literal constants

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

_LIT( KMemSpyNumericDecFormat, "%d" );

_LIT( KMemSpyNumericLongFormat, "%Ld" );

_LIT( KMemSpyCaptionYes, "Yes" );

_LIT( KMemSpyCaptionNo, "No" );

_LIT( KMemSpyCaptionOn, "On" );

_LIT( KMemSpyCaptionOff, "Off" );

_LIT( KMemSpyUnavailable, "Unavailable" );

_LIT( KMemSpyDead, "Dead" );

_LIT( KMemSpyNoItems, "(No items)" );

CMemSpyThreadInfoItemBase::CMemSpyThreadInfoItemBase( CMemSpyThreadInfoContainer& aContainer, TMemSpyThreadInfoItemType aType, TBool aAsyncConstruction )

:   CMemSpyEngineObject( aContainer ), iContainer( aContainer ), iCallBack( CActive::EPriorityLow ), iType( aType )

    {

    if  ( aAsyncConstruction )

        {

        TCallBack callBackMethod( CallConstructL, this );

        iCallBack.Set( callBackMethod );

        iCallBack.CallBack();

        }

    }

CMemSpyThreadInfoItemBase::~CMemSpyThreadInfoItemBase()

    {

    TRAP_IGNORE( iContainer.NotifyObserverL( MMemSpyThreadInfoContainerObserver::EInfoItemDestroyed, iType ) );

    //

    iItems.ResetAndDestroy();

    iItems.Close();

    }

TInt CMemSpyThreadInfoItemBase::CallConstructL( TAny* aSelf )

    {

    CMemSpyThreadInfoItemBase* self = reinterpret_cast< CMemSpyThreadInfoItemBase* >( aSelf );

    self->iReady = EFalse;

    // Don't try to refresh dead thread

    TInt err = KErrNone;

    if ( !self->Container().Thread().IsDead() )

        {

        TRAP(err, self->ConstructL());

        if  ( err != KErrNone )

            {

    #ifdef _DEBUG

            RDebug::Printf( "CMemSpyThreadInfoItemBase::CallConstructL() - construction err: %d, iType: %d", err, self->iType );

    #endif

            self->AddItemL( KMemSpyUnavailable, KNullDesC );

            self->iIsEmpty = ETrue;

            }

        else if ( self->MdcaCount() == 0 )

            {

            self->AddItemL( KMemSpyNoItems, KNullDesC );

            self->iIsEmpty = ETrue;

            }        

        }

    else

        {

        self->AddItemL( KMemSpyDead, KNullDesC );

        self->iIsEmpty = ETrue;

        }

    //

    self->iReady = ETrue;

    return KErrNone;

    }

EXPORT_C TInt CMemSpyThreadInfoItemBase::MdcaCount() const

    {

    return iItems.Count();

    }

EXPORT_C TPtrC CMemSpyThreadInfoItemBase::MdcaPoint( TInt aIndex ) const

    {

    CItem* item = iItems[ aIndex ];

    return TPtrC( item->Combined() );

    }

EXPORT_C CMemSpyEngine& CMemSpyThreadInfoItemBase::Engine() const

    {

    return iContainer.Engine();

    }

EXPORT_C void CMemSpyThreadInfoItemBase::PrintL()

    {

    const TInt count = iItems.Count();

    if  ( count > 0 && !iIsEmpty )

        {

        CMemSpyEngine& engine = Engine();

        CMemSpyEngineOutputSink& sink = engine.Sink();

        HBufC* name = MemSpyEngineUtils::CleanupTextLC( Name() );

        sink.OutputSectionHeadingL( *name, TChar('-') );

        CleanupStack::PopAndDestroy( name );

        sink.OutputPrefixSetLC( _L("  ") ); // Slight insertion

        // First pass to get max lengths

        TInt maxLengthCaption = 0;

        TInt maxLengthValue = 0;

        for( TInt j=0; j<count; j++ )

            {

            const CItem* item = iItems[ j ];

            maxLengthCaption = Max( maxLengthCaption, item->Caption().Length() );

            maxLengthValue = Max( maxLengthValue, item->Value().Length() );

            }

        // Second pass - real this time - to print the values

        HBufC* line = HBufC::NewLC( ( maxLengthCaption + maxLengthValue ) + 20 );

        TPtr pLine( line->Des() );

        //

        for( TInt i=0; i<count; i++ )

            {

            const CItem* item = iItems[ i ];

            // Remove initial tabs in caption

            HBufC* caption = MemSpyEngineUtils::CleanupTextLC( item->Caption() );

            // Create value item & replace any further tabs

            HBufC* value = MemSpyEngineUtils::CleanupTextLC( item->Value() );

            // Now format the final line, with padding.

            pLine.Justify( *caption, maxLengthCaption + 3, ELeft, TChar(' ') );

            pLine.Append( *value );

            CleanupStack::PopAndDestroy( 2, caption );

            // Sink output

            sink.OutputLineL( pLine );

            }

        //

        CleanupStack::PopAndDestroy( line );

        sink.OutputBlankLineL();

        CleanupStack::PopAndDestroy(); // clear prefix

        }

    }

void CMemSpyThreadInfoItemBase::AddItemL( const TDesC& aCaption, const TDesC& aValue )

    {

    CItem* item = CItem::NewLC( aCaption, aValue );

    iItems.AppendL( item );

    CleanupStack::Pop( item );

    }

void CMemSpyThreadInfoItemBase::AddItemHexL( const TDesC& aCaption, TUint aValue )

    {

    TBuf<KMemSpyNumericFormatBufferSize> val;

    val.Format( KMemSpyNumericHexFormat, aValue );

    AddItemL( aCaption, val );

    }

void CMemSpyThreadInfoItemBase::AddItemDecimalL( const TDesC& aCaption, TInt aValue )

    {

    TBuf<KMemSpyNumericFormatBufferSize> val;

    val.Format( KMemSpyNumericDecFormat, aValue );

    AddItemL( aCaption, val );

    }

void CMemSpyThreadInfoItemBase::AddItemLongL( const TDesC& aCaption, const TInt64& aValue )

    {

    TBuf<KMemSpyNumericFormatBufferSize> val;

    val.Format( KMemSpyNumericLongFormat, aValue );

    AddItemL( aCaption, val );

    }

void CMemSpyThreadInfoItemBase::AddItemYesNoL( const TDesC& aCaption, TBool aYes )

    {

    CItem* item = CItem::NewYesNoLC( aCaption, aYes );

    iItems.AppendL( item );

    CleanupStack::Pop( item );

    }

void CMemSpyThreadInfoItemBase::AddItemOnOffL( const TDesC& aCaption, TBool aOn )

    {

    CItem* item = CItem::NewOnOffLC( aCaption, aOn );

    iItems.AppendL( item );

    CleanupStack::Pop( item );

    }

void CMemSpyThreadInfoItemBase::AddItemPercentageL( const TDesC& aCaption, TInt aOneHundredPercentValue, TInt aValue )

    {

    const TMemSpyPercentText val( MemSpyEngineUtils::FormatPercentage( TReal( aOneHundredPercentValue ), TReal( aValue ) ) );

    AddItemL( aCaption, val );

    }

EXPORT_C void CMemSpyThreadInfoItemBase::RebuildL()

    {

    Reset();

    CallConstructL( this );

    }

EXPORT_C TBool CMemSpyThreadInfoItemBase::IsReady() const

    {

    return iReady;

    }

EXPORT_C TMemSpyThreadInfoItemType CMemSpyThreadInfoItemBase::Type() const

    {

    return iType;

    }

void CMemSpyThreadInfoItemBase::Reset()

    {

    iItems.ResetAndDestroy();

    }

void CMemSpyThreadInfoItemBase::StripProcessAndThreadNames( TDes& aText )

    {

    StripProcessName( aText );

    StripThreadName( aText );

    }

void CMemSpyThreadInfoItemBase::StripProcessName( TDes& aText )

    {

    CMemSpyProcess& process = Container().Thread().Process();

    const TPtrC processName( process.Name() );

    TFullName temp;

    //

    _LIT( KProcessNameUidFormat1, "%S.exe[%08x]" );

    temp.Format( KProcessNameUidFormat1, &processName, process.SID() );

    const TBool stripped = MemSpyEngineUtils::StripText( aText, temp );

    //

    if  ( stripped == EFalse )

        {

        _LIT( KProcessNameUidFormat2, "%S[%08x]" );

        temp.Format( KProcessNameUidFormat2, &processName, process.SID() );

        MemSpyEngineUtils::StripText( aText, temp );

        }

    }

void CMemSpyThreadInfoItemBase::StripThreadName( TDes& aText )

    {

    CMemSpyThread& thread = Container().Thread();

    const TPtrC threadName( thread.Name() );

    const TBool stripped = MemSpyEngineUtils::StripText( aText, threadName );

    (void) stripped;

    }

CMemSpyThreadInfoItemBase::CItem& CMemSpyThreadInfoItemBase::Item( TInt aIndex )

    {

    CItem* item = iItems[ aIndex ];

    return *item;

    }

const CMemSpyThreadInfoItemBase::CItem& CMemSpyThreadInfoItemBase::Item( TInt aIndex ) const

    {

    const CItem* item = iItems[ aIndex ];

    return *item;

    }

CMemSpyThreadInfoItemBase::CItem::CItem()

    {

    }

CMemSpyThreadInfoItemBase::CItem::~CItem()

    {

    delete iCaption;

    delete iValue;

    delete iCombined;

    }

void CMemSpyThreadInfoItemBase::CItem::ConstructL( const TDesC& aCaption, const TDesC& aValue )

    {

    iCaption = aCaption.AllocL();

    iValue = aValue.AllocL();

    //

    UpdateCombinedL();

    }

CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewLC( const CItem& aCopyMe )

    {

    CItem* self = new(ELeave) CItem();

    CleanupStack::PushL( self );

    self->ConstructL( aCopyMe.Caption(), aCopyMe.Value() );

    return self;

    }

CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewLC( const TDesC& aCaption )

    {

    CItem* self = new(ELeave) CItem();

    CleanupStack::PushL( self );

    self->ConstructL( aCaption, KNullDesC );

    return self;

    }

CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewLC( const TDesC& aCaption, const TDesC& aValue )

    {

    CItem* self = new(ELeave) CItem();

    CleanupStack::PushL( self );

    self->ConstructL( aCaption, aValue );

    return self;

    }

CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewHexLC( const TDesC& aCaption, TUint aValue )

    {

    CItem* ret = CItem::NewLC( aCaption );

    ret->SetHexL( aValue );

    return ret;

    }

CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewDecimalLC( const TDesC& aCaption, TInt aValue )

    {

    CItem* ret = CItem::NewLC( aCaption );

    ret->SetDecimalL( aValue );

    return ret;

    }

CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewLongLC( const TDesC& aCaption, const TInt64& aValue )

    {

    CItem* ret = CItem::NewLC( aCaption );

    ret->SetLongL( aValue );

    return ret;

    }

CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewYesNoLC( const TDesC& aCaption, TBool aYes )

    {

    CItem* ret = CItem::NewLC( aCaption );

    ret->SetYesNoL( aYes );

    return ret;

    }

CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewOnOffLC( const TDesC& aCaption, TBool aOn )

    {

    CItem* ret = CItem::NewLC( aCaption );

    ret->SetOnOffL( aOn );

    return ret;

    }

CMemSpyThreadInfoItemBase::CItem* CMemSpyThreadInfoItemBase::CItem::NewPercentageLC( const TDesC& aCaption, TInt aOneHundredPercentValue, TInt aValue )

    {

    CItem* ret = CItem::NewLC( aCaption );

    ret->SetPercentageL( aOneHundredPercentValue, aValue );

    return ret;

    }

void CMemSpyThreadInfoItemBase::CItem::SetValueL( const TDesC& aValue )

    {

    if  ( iValue == NULL )

        {

        iValue = aValue.AllocL();

        }

    else

        {

        if  ( iValue->Des().MaxLength() < aValue.Length() )

            {

            iValue = iValue->ReAllocL( aValue.Length() );

            }

        // Now its safe to assign new content

        *iValue = aValue;

        }

    UpdateCombinedL();

    }

void CMemSpyThreadInfoItemBase::CItem::SetHexL( TUint aValue )

    {

    TBuf<KMemSpyNumericFormatBufferSize> val;

    val.Format( KMemSpyNumericHexFormat, aValue );

    SetValueL( val );

    }

void CMemSpyThreadInfoItemBase::CItem::SetDecimalL( TInt aValue )

    {

    TBuf<KMemSpyNumericFormatBufferSize> val;

    val.Format( KMemSpyNumericDecFormat, aValue );

    SetValueL( val );

    }

void CMemSpyThreadInfoItemBase::CItem::SetLongL( const TInt64& aValue )

    {

    TBuf<KMemSpyNumericFormatBufferSize> val;

    val.Format( KMemSpyNumericLongFormat, aValue );

    SetValueL( val );

    }

void CMemSpyThreadInfoItemBase::CItem::SetYesNoL( TBool aYes )

    {

    if  ( aYes )

        {

        SetValueL( KMemSpyCaptionYes );

        }

    else

        {

        SetValueL( KMemSpyCaptionNo );

        }

    }

void CMemSpyThreadInfoItemBase::CItem::SetOnOffL( TBool aOn )

    {

    if  ( aOn )

        {

        SetValueL( KMemSpyCaptionOn );

        }

    else

        {

        SetValueL( KMemSpyCaptionOff );

        }

    }

void CMemSpyThreadInfoItemBase::CItem::SetPercentageL( TInt aOneHundredPercentValue, TInt aValue )

    {

    const TMemSpyPercentText val( MemSpyEngineUtils::FormatPercentage( TReal( aOneHundredPercentValue ), TReal( aValue ) ) );

    SetValueL( val );

    }

void CMemSpyThreadInfoItemBase::CItem::UpdateCombinedL()

    {

    const TInt requiredLength = Caption().Length() + Value().Length() + 10;

    //

    if  ( iCombined == NULL )

        {

        iCombined = HBufC::NewL( requiredLength );

        }

    else if ( iCombined->Des().MaxLength() < requiredLength )

        {

        iCombined = iCombined->ReAllocL( requiredLength );

        }

    TPtr pCombined( iCombined->Des() );

    pCombined.Zero();

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

    pCombined.Append( Caption() );

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

    pCombined.Append( Value() );