/*

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

// System includes

#include <e32debug.h>

// Engine includes

#include <memspyengineclientinterface.h>

#include <memspy/engine/memspyengine.h>

#include <memspy/engine/memspyenginehelperheap.h>

#include <memspy/engine/memspyengineoutputsink.h>

#include <memspy/engine/memspyenginehelperstack.h>

#include <memspy/engine/memspyengineobjectthread.h>

#include <memspy/engine/memspyengineobjectprocess.h>

#include <memspy/engine/memspydevicewideoperations.h>

#include <memspy/engine/memspyengineobjectcontainer.h>

#include <memspy/engine/memspyenginehelperkernelcontainers.h>

#include <memspy/engine/memspyengineobjectthreadinfoobjects.h>

#include <memspy/engine/memspyengineobjectthreadinfocontainer.h>

// User includes

#include "ConsoleConstants.h"

#include "ConsoleDWOperation.h"

    {

    CActiveScheduler::Add( this );

    }

CMemSpyConsoleMenu::~CMemSpyConsoleMenu()

    {

    Cancel();

    }

void CMemSpyConsoleMenu::ConstructL()

    {

    DrawMenuL();

    WaitForInput();

    }

    {

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

void CMemSpyConsoleMenu::DrawMenuL()

    {

    iConsole.ClearScreen();

    // First line - sink type (defaults to file)

    _LIT( KLine1, "1 or T. Toggle output mode between file or trace [%S]" );

        {

        _LIT( KLine1Trace, "Trace" );

        iConsole.Printf( KLine1, &KLine1Trace );

        }

    else

        {

        _LIT( KLine1File, "File" );

        iConsole.Printf( KLine1, &KLine1File );

        }

    iConsole.Write( KMemSpyConsoleNewLine );

    // Kernel heap dump

    _LIT( KLine2, "2 or K. Dump kernel heap data" );

    iConsole.Write( KLine2 );

    iConsole.Write( KMemSpyConsoleNewLine );

    // Kernel heap dump

    _LIT( KLine3, "3 or O. Dump kernel object listing" );

    iConsole.Write( KLine3 );

    iConsole.Write( KMemSpyConsoleNewLine );

    // Heap (CSV) listing

    _LIT( KLine4, "4 or H. Heap CSV-information (for all threads)" );

    iConsole.Write( KLine4 );

    iConsole.Write( KMemSpyConsoleNewLine );

    // Stack (CSV) listing

    _LIT( KLine5, "5 or S. Stack CSV-information (for all threads)" );

    iConsole.Write( KLine5 );

    iConsole.Write( KMemSpyConsoleNewLine );

    // Heap data

    _LIT( KLine6, "6 or D. Get heap data for a user-thread" );

    iConsole.Write( KLine6 );

    iConsole.Write( KMemSpyConsoleNewLine );

    // Heap cell listing

    _LIT( KLine7, "7 or L. Get heap cell list for a user-thread" );

    iConsole.Write( KLine7 );

    iConsole.Write( KMemSpyConsoleNewLine );

    // Exit key

    _LIT( KLine8, "8 or X. Exit" );

    iConsole.Write( KLine8 );

    iConsole.Write( KMemSpyConsoleNewLine );

    // Spacer

    iConsole.Write( KMemSpyConsoleNewLine );

    iConsole.Write( KMemSpyConsoleNewLine );

    // Status message

    iStatusMessagePos = iConsole.CursorPos();

    RedrawStatusMessage();

    // Spacer

    iConsole.Write( KMemSpyConsoleNewLine );

    // Show input prompt.

    iCommandPromptPos = iConsole.CursorPos();

    RedrawInputPrompt();

    }

void CMemSpyConsoleMenu::WaitForInput()

    {

    ASSERT( !IsActive() );

    iConsole.Read( iStatus );

    SetActive();

    }

void CMemSpyConsoleMenu::RunL()

    {

    TKeyCode key = iConsole.KeyCode();

    //

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::RunL() - START - key = %d", key );

#endif

    //

    if  ( key == EKeyEnter || key == KMemSpyUiS60KeyCodeButtonOk || key == KMemSpyUiS60KeyCodeRockerEnter )

        {

        TRAP_IGNORE( ProcessCommandBufferL() );

        }

    else if ( key == EKeyEscape || key == KMemSpyUiS60KeyCodeButtonCancel )

        {

        ClearCommandBuffer();

        RedrawInputPrompt();

        }   

    else if ( key == EKeyBackspace )

        {

        const TInt cmdBufLength = iCommandBuffer.Length();

        if  ( cmdBufLength > 0 )

            {

            iCommandBuffer.SetLength( cmdBufLength - 1 );

            RedrawInputPrompt();

            }

        }

    else

        {

        TChar character( key );

        if  ( character.IsPrint() )

            {

            if  ( iCommandBuffer.Length() < iCommandBuffer.MaxLength() )

                {

                iCommandBuffer.Append( TChar( key ) );

                }

            RedrawInputPrompt();

            }

        }

    WaitForInput();

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::RunL() - END" );

#endif

    }

void CMemSpyConsoleMenu::DoCancel()

    {

    iConsole.ReadCancel();

    }

void CMemSpyConsoleMenu::OnCmdSinkTypeToggleL()

    {

    }

void CMemSpyConsoleMenu::OnCmdHeapDataKernelL()

    {

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::OnCmdHeapDataKernelL() - START" );

#endif

    _LIT( KMsg, "Ouputting Kernel data..." );

    RedrawStatusMessage( KMsg );

    RedrawStatusMessage( KNullDesC );

    }

void CMemSpyConsoleMenu::OnCmdKernelObjectListingL()

    {

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::OnCmdKernelObjectListingL() - START" );

#endif

    _LIT( KMsg, "Ouputting Kernel Object listing..." );

    RedrawStatusMessage( KMsg );

    //

    RedrawStatusMessage( KNullDesC );

    }

void CMemSpyConsoleMenu::OnCmdCSVListingStackL()

    {

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::OnCmdCSVListingStackL() - START" );

#endif

    }

void CMemSpyConsoleMenu::OnCmdCSVListingHeapL()

    {

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::OnCmdCSVListingHeapL() - START" );

#endif

    }

void CMemSpyConsoleMenu::OnCmdHeapDataUserL()

    {

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::OnCmdHeapDataUserL() - START" );

#endif

    GetProcessName();

    // Work out what to do.

    iCommandBuffer.Trim();

#ifdef _DEBUG

    RDebug::Print( _L("[MCon] CMemSpyConsoleMenu::OnCmdHeapDataUserL() - requested dump heap for proc: %S"), &iCommandBuffer );

#endif

    if  ( iCommandBuffer.Length() > 0 )

        {

        iConsole.Write( KMemSpyConsoleNewLine );

        iConsole.Write( KMemSpyConsoleNewLine );

        //

        HBufC* cmdBuf = HBufC::NewLC( KMemSpyMaxInputBufferLength + 10 );

        TPtr pCmdBuf( cmdBuf->Des() );

        pCmdBuf.Copy( iCommandBuffer );

        pCmdBuf.Append( KMemSpyConsoleWildcardCharacter );

        //

                    {

                    //

                    iConsole.Printf( KProcessingRequest, &fullThreadName );

                    iConsole.Write( KMemSpyConsoleNewLine );

                    //

                    }

                }

            }

        CleanupStack::PopAndDestroy( cmdBuf );

        DrawMenuL();

        }

    else

        {

        // Bad user data entry

        DrawMenuL();

        _LIT( KInvalidEntry, "*** ERROR - Invalid Command ***" );

        RedrawStatusMessage( KInvalidEntry );

        RedrawInputPrompt();

        }

    }

void CMemSpyConsoleMenu::OnCmdHeapCellListUserL()

    {

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::OnCmdHeapCellListUserL() - START" );

#endif

    GetProcessName();

    // Work out what to do.

    iCommandBuffer.Trim();

    if  ( iCommandBuffer.Length() > 0 )

        {

        iConsole.Write( KMemSpyConsoleNewLine );

        iConsole.Write( KMemSpyConsoleNewLine );

        //

        HBufC* cmdBuf = HBufC::NewLC( KMemSpyMaxInputBufferLength + 10 );

        TPtr pCmdBuf( cmdBuf->Des() );

        pCmdBuf.Copy( iCommandBuffer );

        pCmdBuf.Append( KMemSpyConsoleWildcardCharacter );

        CleanupStack::PopAndDestroy( cmdBuf );

        DrawMenuL();

        }

    else

        {

        // Bad user data entry

        DrawMenuL();

        _LIT( KInvalidEntry, "*** ERROR - Invalid Command ***" );

        RedrawStatusMessage( KInvalidEntry );

        RedrawInputPrompt();

        }

    }

void CMemSpyConsoleMenu::ClearCommandBuffer()

    {

    iCommandBuffer.Zero();

    }

void CMemSpyConsoleMenu::ProcessCommandBufferL()

    {

    iCommandBuffer.Trim();

    //

#ifdef _DEBUG

    RDebug::Print( _L("[MCon] CMemSpyConsoleMenu::ProcessCommandBufferL() - cmd: [%S]"), &iCommandBuffer );

#endif

    //

    TBool validCommand = EFalse;

    if  ( iCommandBuffer.Length() == 1 )

        {

        // Reset if not recognised...

        validCommand = ETrue;

        const TChar cmd = iCommandBuffer[ 0 ]; 

        switch( cmd )

            {

        case '1':

        case 't':

        case 'T':

            OnCmdSinkTypeToggleL();

            break;

        case '2':

        case 'k':

        case 'K':

            OnCmdHeapDataKernelL();

            break;

        case '3':

        case 'o':

        case 'O':

            OnCmdKernelObjectListingL();

            break;

        case '4':

        case 'h':

        case 'H':

            OnCmdCSVListingHeapL();

            break;

        case '5':

        case 's':

        case 'S':

            OnCmdCSVListingStackL();

            break;

        case '6':

        case 'd':

        case 'D':

            OnCmdHeapDataUserL();

            break;

        case '7':

        case 'l':

        case 'L':

            OnCmdHeapCellListUserL();

            break;

        case '8':

        case 'x':

        case 'X':

            CActiveScheduler::Stop();

            return; // NB: avoid redrawing menu when exiting

        default:

            validCommand = EFalse;

            break;

            }

        }

    //

    ClearCommandBuffer();

    //

    if  ( !validCommand )

        {

        _LIT( KInvalidEntry, "*** ERROR - Invalid Command ***" );

        RedrawStatusMessage( KInvalidEntry );

        RedrawInputPrompt();

        }

    else

        {

        DrawMenuL();

        }

#ifdef _DEBUG

    RDebug::Printf( "[MCon] CMemSpyConsoleMenu::ProcessCommandBufferL() - END" );

#endif

    }

void CMemSpyConsoleMenu::RedrawInputPrompt()

    {

    iConsole.SetCursorPosAbs( iCommandPromptPos );

    iConsole.ClearToEndOfLine();

    iConsole.Printf( KMemSpyConsoleInputPrompt, &iCommandBuffer );

    }

void CMemSpyConsoleMenu::RedrawStatusMessage()

    {

    RedrawStatusMessage( KNullDesC );

    }

void CMemSpyConsoleMenu::RedrawStatusMessage( const TDesC& aMessage )

    {

    iConsole.SetCursorPosAbs( iStatusMessagePos );

    iConsole.ClearToEndOfLine();

    iConsole.Write( aMessage );

    iConsole.Write( KMemSpyConsoleNewLine );

    }

void CMemSpyConsoleMenu::GetProcessName()

    {

    iConsole.ClearScreen();

    _LIT( KPromptMessage1, "Enter the full or partial process name" );

    iConsole.Write( KPromptMessage1 );

    iConsole.Write( KMemSpyConsoleNewLine );

    _LIT( KPromptMessage2, "of the process that you are interested in." );

    iConsole.Write( KPromptMessage2 );

    iConsole.Write( KMemSpyConsoleNewLine );

    _LIT( KPromptMessage3, "Press \'enter\' when done." );

    iConsole.Write( KPromptMessage3 );

    iConsole.Write( KMemSpyConsoleNewLine );

    //

    ClearCommandBuffer();

    iConsole.Write( KMemSpyConsoleNewLine );

    iCommandPromptPos = iConsole.CursorPos();

    RedrawInputPrompt();

    //

    TBool done = EFalse;