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

// System includes
#include <eikrted.h>  // for example label control
#include <txtrich.h>
#include <apgtask.h>
#include <akntitle.h>
#include <akncontext.h>
#include <aknnavi.h>
#include <eiklbx.h>
#include <eiklbm.h>
#include <avkon.hrh>

// Engine includes
#include <memspy/engine/memspyengine.h>
#include <memspy/engine/memspyengineutils.h>
#include <memspy/engine/memspyengineoutputsink.h>

// User includes
#include "MemSpyAppUi.h"
#include "MemSpyDocument.h"
#include "MemSpyContainer.h"
#include "MemSpyContainerObserver.h"




CMemSpyViewBase::CMemSpyViewBase( CMemSpyEngine& aEngine, MMemSpyViewObserver& aObserver )
:   iEngine( aEngine ), iObserver( aObserver )
    {
    }


CMemSpyViewBase::~CMemSpyViewBase()
    {
    delete iListBox;
    }
 

void CMemSpyViewBase::ConstructL( const TRect& aRect, CCoeControl& aContainer, TAny* /*aSelectionRune*/ )
    {
    iSettings = &static_cast< CMemSpyAppUi* >( iEikonEnv->EikAppUi() )->MemSpyDocument().Settings();
    //
    User::LeaveIfError( SetParent( &aContainer ) );
    SetContainerWindowL( aContainer );
    
    SetComponentsToInheritVisibility( ETrue );

    iListBox = ConstructListBoxL();
    if  ( iListBox )
        {
        iListBox->SetFocus( ETrue );
        }

    SetRect( aRect );
    ActivateL();
    }


void CMemSpyViewBase::SetTitleL( const TDesC& aText )
    {
    CEikStatusPane* statusPane = static_cast<CAknAppUi*> ( iEikonEnv->EikAppUi() )->StatusPane();
    CAknTitlePane* title = static_cast<CAknTitlePane*> ( statusPane->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );
    title->SetTextL( aText );
    }


TPtrC CMemSpyViewBase::TitleL() const
    {
    TPtrC ret( KNullDesC );
    //
    CEikStatusPane* statusPane = static_cast<CAknAppUi*> ( iEikonEnv->EikAppUi() )->StatusPane();
    CAknTitlePane* title = static_cast<CAknTitlePane*> ( statusPane->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );
    if  ( title->Text() )
        {
        ret.Set( *title->Text() );
        }
    //
    return ret;
    }


CMemSpyViewBase* CMemSpyViewBase::PrepareParentViewL()
    {
    return NULL;
    }


CMemSpyViewBase* CMemSpyViewBase::PrepareChildViewL()
    {
    return NULL;
    }
    
    
void CMemSpyViewBase::RefreshL()
    {
    if  ( iListBox )
        {
        iListBox->UpdateScrollBarsL();
        }

    DrawDeferred();
    }


TBool CMemSpyViewBase::HandleCommandL( TInt aCommand )
    {
    TBool handled = ETrue;
    //
    switch( aCommand )
        {
	case EMemSpyCmdViewOutputToSink:
        OnCmdViewOutputToSinkL();
        break;
    default:
        handled = EFalse;
        break;
        }
    //
    return handled;
    }


void CMemSpyViewBase::DynInitMenuPaneL( TInt /*aResourceId*/, CEikMenuPane* /*aMenuPane*/ )
    {
    }


TUint CMemSpyViewBase::MenuCascadeResourceId() const
    {
    return 0;
    }


TInt CMemSpyViewBase::MenuCascadeCommandId() const
    {
    return 0;
    }


void CMemSpyViewBase::OnCmdViewOutputToSinkL()
    {
    if  ( iListBox )
        {
        // Prepare sink
        CMemSpyEngineOutputSink& sink = iEngine.Sink();
        HBufC* name = MemSpyEngineUtils::CleanupTextLC( TitleL() );
        sink.OutputSectionHeadingL( *name, TChar('-') );
        CleanupStack::PopAndDestroy( name );
        sink.OutputPrefixSetLC( _L("  ") ); // Slight insertion
        
        // Get text from underlying listbox model...
        MTextListBoxModel* model = static_cast< MTextListBoxModel* >( iListBox->Model() );
        const TInt count = model->NumberOfItems();

        // First pass to get max lengths
        TInt maxLengthCaption = 0;
        TInt maxLengthValue = 0;

        for( TInt j=0; j<count; j++ )
            {
            const TPtrC pItem( model->ItemText( j ) );
            const TInt length = pItem.Length();
    
            // Check if its split or not?
            const TInt splitPos = pItem.FindF( _L("\t\t") );
            if  ( splitPos > 0 )
                {
                maxLengthCaption = Max( maxLengthCaption, splitPos );
                maxLengthValue = Max( maxLengthValue, length - splitPos + 1 );
                }
            else
                {
                maxLengthCaption = Max( maxLengthCaption, 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 TPtrC pItem( model->ItemText( i ) );
            const TInt length = pItem.Length();
            //
            TPtrC pCaption( KNullDesC );
            TPtrC pValue( KNullDesC );
            //
            const TInt splitPos = pItem.FindF( _L("\t\t") );
            if  ( splitPos > 0 )
                {
                pCaption.Set( pItem.Left( splitPos ) );
                pValue.Set( pItem.Mid( splitPos + 1 ) );
                }
            else
                {
                pCaption.Set( pItem );
                }

            // Remove initial tabs in caption
            HBufC* caption = MemSpyEngineUtils::CleanupTextLC( pCaption );
        
            // Create value item & replace any further tabs
            HBufC* value = MemSpyEngineUtils::CleanupTextLC( pValue );

            // 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 );
            }

        // Remove prefix & tidy up
        CleanupStack::PopAndDestroy( line );
        sink.OutputBlankLineL();
        CleanupStack::PopAndDestroy(); // clear prefix
        }
    }


CEikListBox* CMemSpyViewBase::ConstructListBoxL()
    {
    delete iListBox;
    iListBox = NULL;
    CAknSettingStyleListBox* listbox = new(ELeave) CAknSettingStyleListBox();
    iListBox = listbox;
    //
    listbox->ConstructL( this, EAknListBoxSelectionList | EAknListBoxLoopScrolling );
    listbox->SetContainerWindowL( *this );
    listbox->CreateScrollBarFrameL( ETrue );
    SetListBoxModelL();
    listbox->ScrollBarFrame()->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );
    listbox->SetListBoxObserver( this );
    listbox->SetObserver( this );
    listbox->SetComponentsToInheritVisibility( ETrue );
    //
    return listbox;
    }


void CMemSpyViewBase::HandleListBoxItemActionedL( TInt /*aIndex*/ )
    {
    ReportEventL( MMemSpyViewObserver::EEventItemActioned );
    }


void CMemSpyViewBase::HandleListBoxItemSelectedL( TInt /*aIndex*/ )
    {
    ReportEventL( MMemSpyViewObserver::EEventItemSelected );
    }


void CMemSpyViewBase::ReportEventL( MMemSpyViewObserver::TViewEventType aEvent, TAny* aContext )
    {
    iObserver.HandleMemSpyViewEventL( aEvent, ViewType(), *this, aContext );
    }


void CMemSpyViewBase::SetListBoxCurrentItemIndexL( TInt aIndex )
    {
    if  ( iListBox )
        {
        iListBox->SetCurrentItemIndex( aIndex );
        HandleListBoxItemSelectedL( aIndex );
        }
    }


CMemSpyContainer& CMemSpyViewBase::Container()
    {
    CMemSpyAppUi* appUi = static_cast< CMemSpyAppUi* >( iEikonEnv->EikAppUi() );
    return appUi->Container();
    }


CMemSpySettings& CMemSpyViewBase::Settings()
    {
    return *iSettings;
    }


const CMemSpySettings& CMemSpyViewBase::Settings() const
    {
    return *iSettings;
    }

    
void CMemSpyViewBase::Draw( const TRect& aRect ) const
    {
    CWindowGc& gc = SystemGc();
    //
    gc.SetPenStyle( CGraphicsContext::ENullPen );
    gc.SetBrushColor( KRgbWhite );
    gc.SetBrushStyle( CGraphicsContext::ESolidBrush );
    gc.DrawRect( aRect );
    }


void CMemSpyViewBase::SizeChanged()
    {
    if  ( iListBox )
        {
        iListBox->SetRect( Rect() );
        }
    }


void CMemSpyViewBase::FocusChanged(TDrawNow /*aDrawNow*/)
    {
    if  ( iListBox )
        {
        iListBox->SetFocus( IsFocused() );
        }
    }


TInt CMemSpyViewBase::CountComponentControls() const
    {
    TInt count = 0;
    if  ( iListBox )
        {
        ++count;
        }
    //
    return count;
    }


CCoeControl* CMemSpyViewBase::ComponentControl(TInt aIndex) const
    {
    switch ( aIndex )
        {
    case 0:
        return iListBox;
    default:
        return NULL;
        }
    }


TKeyResponse CMemSpyViewBase::OfferKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aType )
	{
    TKeyResponse resp = EKeyWasNotConsumed;
    if  ( iListBox )
        {
        resp = iListBox->OfferKeyEventL( aKeyEvent, aType );
        }
    //
    if ( resp == EKeyWasNotConsumed && aType == EEventKeyDown && aKeyEvent.iCode == EKeyBackspace )
        {
        // When backspace is pushed, go to the parent view
        CMemSpyAppUi* appUi = static_cast< CMemSpyAppUi* >( iEikonEnv->EikAppUi() );
        appUi->Container().NavigateToParentViewL();
        resp = EKeyWasConsumed;
        }
    //
	return resp;
	}


void CMemSpyViewBase::HandleControlEventL( CCoeControl* aControl,TCoeEvent aEventType )
    {
    if  ( aControl == iListBox )
        {
        if  ( aEventType == MCoeControlObserver::EEventStateChanged )
            {
            const TInt index = iListBox->CurrentItemIndex();
            HandleListBoxItemSelectedL( index );
            }
        }
    }


void CMemSpyViewBase::HandleListBoxEventL( CEikListBox* /*aListBox*/, TListBoxEvent aEventType )
    {
    const TInt index = iListBox->CurrentItemIndex();
    //
    switch (aEventType)
        {
    case EEventItemActioned:
    case EEventEnterKeyPressed:
    case EEventItemDoubleClicked:
        HandleListBoxItemActionedL( index );
        break;

    default:
        break;
        }
    }