/*

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

// System includes

#include <e32debug.h>

// User includes

#include <memspy/engine/memspyengineutils.h>

#include <memspy/engine/memspyengineoutputsink.h>

#include "MemSpyEngineOutputListItem.h"

// Constants

_LIT( KMemSpyOutputListPseudoBlankItem, " " );

CMemSpyEngineOutputList::CMemSpyEngineOutputList( CMemSpyEngineOutputSink* aSink )

:   iSink( aSink ), iFormatBufferPtr( NULL, 0 )

    {

    }

CMemSpyEngineOutputList::~CMemSpyEngineOutputList()

    {

    delete iFormatBuffer;

    iItems.ResetAndDestroy();

    iItems.Close();

    }

void CMemSpyEngineOutputList::ConstructL()

    {

    iFormatBuffer = HBufC::NewL( 1024 );

    iFormatBufferPtr.Set( iFormatBuffer->Des() );

    }

CMemSpyEngineOutputList* CMemSpyEngineOutputList::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CMemSpyEngineOutputList* CMemSpyEngineOutputList::NewLC( CMemSpyEngineOutputSink& aSink )

    {

    CMemSpyEngineOutputList* self = new(ELeave) CMemSpyEngineOutputList( &aSink );

    CleanupStack::PushL( self );

    // No need to call ConstructL - it uses the sink's format buffer

    return self;

    }

TInt CMemSpyEngineOutputList::MdcaCount() const

    {

    return iItems.Count();

    }

TPtrC CMemSpyEngineOutputList::MdcaPoint( TInt aPos ) const

    {

    CMemSpyEngineOutputListItem* item = iItems[ aPos ];

    return TPtrC( item->Combined() );

    }

void CMemSpyEngineOutputList::PrintL()

    {

    ASSERT( iSink != NULL );

    PrintL( *iSink );

    }

void CMemSpyEngineOutputList::PrintL( CMemSpyEngineOutputSink& aSink )

    {

    const TInt count = iItems.Count();

    if  ( count > 0 )

        {

        // First pass to get max lengths

        TInt maxLengthCaption = 0;

        TInt maxLengthValue = 0;

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

            {

            const CMemSpyEngineOutputListItem* item = iItems[ j ];

			if (item->Value().Length())

				{

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

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

				}

			else

				{

				// If something doesn't have a value (ie it's a section header, represented as just a caption) then the caption

				// shouldn't be factored into the maxcaptionlength. But consider it in maxlengthValue to make sure we actually

				// make the overall buffers big enough

				maxLengthValue = Max( maxLengthValue, item->Caption().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 CMemSpyEngineOutputListItem* 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.

			if (value->Length()) 

				{

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

				}

			else

				{

				// items without value (ie just captions, ie section headers) aren't constrained by the maxLengthCaption restriction

				pLine.Copy(*caption);

				}

            pLine.Append( *value );

            CleanupStack::PopAndDestroy( 2, caption );

            // Sink output

            aSink.OutputLineL( pLine );

            }

        //

        CleanupStack::PopAndDestroy( line );

        }

    }

CMemSpyEngineOutputListItem& CMemSpyEngineOutputList::Item( TInt aPos )

    {

    CMemSpyEngineOutputListItem* ret = iItems[ aPos ];

    return *ret;

    }

const CMemSpyEngineOutputListItem& CMemSpyEngineOutputList::Item( TInt aPos ) const

    {

    const CMemSpyEngineOutputListItem* ret = iItems[ aPos ];

    return *ret;

    }

void CMemSpyEngineOutputList::AddItemL( const TDesC& aCaption )

    {

    AddItemL( aCaption, KNullDesC );

    }

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

    {

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

    iItems.AppendL( item );

    CleanupStack::Pop( item );

    }

void CMemSpyEngineOutputList::AddItemL( const TDesC& aCaption, TInt aValue )

    {

    CMemSpyEngineOutputListItem* item = CMemSpyEngineOutputListItem::NewDecimalLC( aCaption, aValue );

    iItems.AppendL( item );

    CleanupStack::Pop( item );

    }

void CMemSpyEngineOutputList::AddItemL( const TDesC& aCaption, TUint aValue )

    {

    CMemSpyEngineOutputListItem* item = CMemSpyEngineOutputListItem::NewDecimalLC( aCaption, aValue );

    iItems.AppendL( item );

    CleanupStack::Pop( item );

    }

void CMemSpyEngineOutputList::AddItemL( const TDesC& aCaption, const TInt64& aValue )

    {

    CMemSpyEngineOutputListItem* item = CMemSpyEngineOutputListItem::NewLongLC( aCaption, aValue );

    iItems.AppendL( item );

    CleanupStack::Pop( item );

    }

void CMemSpyEngineOutputList::AddItemL( const TDesC& aCaption, TAny* aValue )

    {

    AddItemHexL( aCaption, (TUint) aValue );

    }

void CMemSpyEngineOutputList::AddItemL( const TDesC& aCaption, TUint* aValue )

    {

    AddItemHexL( aCaption, (TUint) aValue );

    }

void CMemSpyEngineOutputList::AddItemL( const TDesC& aCaption, TUint8* aValue )

    {

    AddItemHexL( aCaption, (TUint) aValue );

    }

void CMemSpyEngineOutputList::AddItemFormatL( TRefByValue<const TDesC> aFormat, ... )

    {

	VA_LIST list;

	VA_START(list,aFormat);

    TPtr formatBuffer( FormatBuffer() );

	formatBuffer.Zero();

    formatBuffer.FormatList( aFormat, list );

    //

    AddItemL( formatBuffer, KNullDesC );

    }

void CMemSpyEngineOutputList::AddItemFormatL( const TDesC& aCaption, TRefByValue<const TDesC> aValueFormat, ... )

    {

	VA_LIST list;

	VA_START(list,aValueFormat);

    TPtr formatBuffer( FormatBuffer() );

	formatBuffer.Zero();

    formatBuffer.FormatList( aValueFormat, list );

    //

    AddItemL( aCaption, formatBuffer );

    }

void CMemSpyEngineOutputList::AddItemFormatUCL( TRefByValue<const TDesC> aFormat, ... )

    {

	VA_LIST list;

	VA_START(list,aFormat);

    TPtr formatBuffer( FormatBuffer() );

	formatBuffer.Zero();

    formatBuffer.FormatList( aFormat, list );

    //

    AddItemUCL( formatBuffer, KNullDesC );

    }

void CMemSpyEngineOutputList::AddItemUCL( const TDesC& aCaption, const TDesC& aValue )

    {

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

    iItems.AppendL( item );

    CleanupStack::Pop( item );

    //

    item->iCaption->Des().UpperCase();

    item->UpdateCombinedL();

    }

void CMemSpyEngineOutputList::AddItemFormatUCL( const TDesC& aCaption, TRefByValue<const TDesC> aValueFormat, ... )

    {

	VA_LIST list;

	VA_START(list,aValueFormat);

    TPtr formatBuffer( FormatBuffer() );

	formatBuffer.Zero();

    formatBuffer.FormatList( aValueFormat, list );

    //

    AddItemUCL( aCaption, formatBuffer );

    }

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

    {

    CMemSpyEngineOutputListItem* item = CMemSpyEngineOutputListItem::NewHexLC( aCaption, aValue );

    iItems.AppendL( item );

    CleanupStack::Pop( item );

    }

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

    {

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

    iItems.AppendL( item );

    CleanupStack::Pop( item );

    }

void CMemSpyEngineOutputList::AddItemTrueFalseL( const TDesC& aCaption, TBool aTrue )

    {

    CMemSpyEngineOutputListItem* item = CMemSpyEngineOutputListItem::NewTrueFalseLC( aCaption, aTrue );

    iItems.AppendL( item );

    CleanupStack::Pop( item );

    }

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

    {

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

    iItems.AppendL( item );

    CleanupStack::Pop( item );

    }

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

    {

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

    AddItemL( aCaption, val );

    }

void CMemSpyEngineOutputList::AddBlankItemL( TInt aRepetitions )

    {

    const TInt count = Count();

    InsertBlankItemL( count, aRepetitions );

    }

void CMemSpyEngineOutputList::AddUnderlineForPreviousItemL( TChar aUnderlineCharacter, TInt aBlankItemCount )

    {

    const TInt count = iItems.Count();

    if  ( count > 0 )

        {

        InsertUnderlineForItemAtL( count - 1, aUnderlineCharacter, aBlankItemCount );

        }

    }

void CMemSpyEngineOutputList::InsertItemL( TInt aPos, const TDesC& aCaption )

    {

    InsertItemL( aPos, aCaption, KNullDesC );

    }

void CMemSpyEngineOutputList::InsertItemL( TInt aPos, const TDesC& aCaption, const TDesC& aValue )

    {

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

    iItems.InsertL( item, aPos );

    CleanupStack::Pop( item );

    }

void CMemSpyEngineOutputList::InsertItemFormatUCL( TInt aPos, TRefByValue<const TDesC> aValueFormat, ... )

    {

	VA_LIST list;

	VA_START(list,aValueFormat);

    TPtr formatBuffer( FormatBuffer() );

	formatBuffer.Zero();

    formatBuffer.FormatList( aValueFormat, list );

    //

    InsertItemL( aPos, formatBuffer, KNullDesC );

    }

void CMemSpyEngineOutputList::InsertBlankItemL( TInt aPos, TInt aRepetitions )

    {

    while( aRepetitions-- > 0 )

        {

        InsertItemL( aPos, KMemSpyOutputListPseudoBlankItem, KMemSpyOutputListPseudoBlankItem );

        }

    }

void CMemSpyEngineOutputList::InsertUnderlineForItemAtL( TInt aPos, TChar aUnderlineCharacter, TInt aBlankItemCount )

    {

    const CMemSpyEngineOutputListItem& item = Item( aPos );

    // Clean text

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

    //RDebug::Print( _L("CMemSpyEngineOutputList::AddUnderlineForPreviousItemL() - [%3d] caption: %S"), caption->Length(), caption );

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

    //RDebug::Print( _L("CMemSpyEngineOutputList::AddUnderlineForPreviousItemL() - [%3d] value: %S"), value->Length(), value );

    // Make underline descriptor

    TBuf<1> underline;

    underline.Append( aUnderlineCharacter );

    // Make underline items

    const TInt lenCaption = caption->Length();

    if ( lenCaption > 0 )

        {

        TPtr pText( caption->Des() );

        pText.Repeat( underline );

        }

    const TInt lenValue = value->Length();

    if ( lenValue > 0 )

        {

        TPtr pText( value->Des() );

        pText.Repeat( underline );

        }

    // Create new item

    InsertItemL( aPos + 1, *caption, *value );

    // Clean up

    CleanupStack::PopAndDestroy( 2, caption );

    // Make blank row if needed

    InsertBlankItemL( aPos + 2, aBlankItemCount );

    }

TPtr& CMemSpyEngineOutputList::FormatBuffer()

    {

    if  ( iSink )

        {

        return iSink->FormatBuffer();

        }

    //

    return iFormatBufferPtr;

    }