/*

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

// System includes

#include <eikspane.h>

#include <aknnavide.h> 

#include <akntabgrp.h>

#include <eikclbd.h>

#include <AknQueryDialog.h>

#include <aknnotewrappers.h>

#include <apgwgnam.h>

#include <aknmessagequerydialog.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/memspyenginehelperkernelcontainers.h>

#include <memspy/engine/memspyenginehelperserver.h>

#include <memspy/engine/memspyenginehelpercondvar.h>

// User includes

#include "MemSpyUiUtils.h"

#include "MemSpyViewKernel.h"

#include "MemSpyContainerObserver.h"

#include "MemSpyViewKernelContainers.h"

const TInt KMaxInfoLength = 128;

CMemSpyViewKernelObjects::CMemSpyViewKernelObjects( CMemSpyEngine& aEngine, MMemSpyViewObserver& aObserver, TMemSpyDriverContainerType aObjectType )

:   CMemSpyViewBase( aEngine, aObserver ),

    iObjectType( aObjectType ),

    iCurrItemIndex( KErrNotFound )

    {

    }

CMemSpyViewKernelObjects::~CMemSpyViewKernelObjects()

    {

    if ( iNavContainer && iNavDecorator )

        {

        iNavContainer->Pop( iNavDecorator );

        delete iNavDecorator;

        }

    delete iModel;

    delete iItems;

    delete iObjectList;

    }

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

    {

    _LIT( KTitle, "Kernel Objects" );

    SetTitleL( KTitle );

    iItems = new(ELeave) CDesCArrayFlat(5);

    //

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

    CreateTabsL();

    }

CEikListBox* CMemSpyViewKernelObjects::ConstructListBoxL()

    {

    delete iListBox;

    iListBox = NULL;

    CAknSingleStyleListBox* listbox = new (ELeave) CAknSingleStyleListBox();

    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->ItemDrawer()->ColumnData()->EnableMarqueeL(ETrue);

    listbox->SetObserver( this );

    return listbox;

    }

void CMemSpyViewKernelObjects::RefreshL()

    {

    SetListBoxModelL();

    CMemSpyViewBase::RefreshL();

    }

TMemSpyViewType CMemSpyViewKernelObjects::ViewType() const

    {

    return EMemSpyViewTypeKernelObjects;

    }

CMemSpyViewBase* CMemSpyViewKernelObjects::PrepareParentViewL()

    {

    if ( iNavContainer && iNavDecorator )

        {

        iNavContainer->Pop( iNavDecorator );

        delete iNavDecorator;

        iNavDecorator = NULL;

        }

    CMemSpyViewBase* parent = new(ELeave) CMemSpyViewKernelContainers( iEngine, iObserver );

    CleanupStack::PushL( parent );

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

    CleanupStack::Pop( parent );

    return parent;

    }

CMemSpyViewBase* CMemSpyViewKernelObjects::PrepareChildViewL()

    {

    CMemSpyViewBase* child = NULL;

    if ( iListBox && 

         iListBox->Model()->NumberOfItems() && 

         iListBox->CurrentItemIndex() > KErrNotFound )

        {

        DetailsL();

        }

    return child;

    }

void CMemSpyViewKernelObjects::DynInitMenuPaneL( TInt aResourceId, CEikMenuPane* aMenuPane )

    {

    if  ( aResourceId == R_MEMSPY_MENUPANE )

       {

       if ( iObjectType > EMemSpyDriverContainerTypeProcess )

           {

           // Display Terminate, Switch to, End and Panic

           // commands only for Threads and processes

           aMenuPane->SetItemDimmed( EMemSpyCmdKernelObjects, ETrue );

           }

        }

    }

void CMemSpyViewKernelObjects::SetListBoxModelL()

    {

    _LIT( KLineFormatSpec, "\t%S" );

    // Take ownership of new model

    CMemSpyEngineHelperKernelContainers& kernelContainerManager = iEngine.HelperKernelContainers();

    CMemSpyEngineGenericKernelObjectContainer* model = kernelContainerManager.ObjectsAllL();

    delete iModel;

    iModel = model;

    iItems->Reset();

    delete iObjectList;

    iObjectList = NULL;

    iObjectList = kernelContainerManager.ObjectsForSpecificContainerL( iObjectType );

    // TODO: CMemSpyEngineGenericKernelObjectList could inherit MDesCArray like

    // CMemSpyEngineGenericKernelObjectContainer does. iObjectList could then be passed

    // to listbox model:

    // listbox->Model()->SetItemTextArray( iObjectList );

    TName item;

    TName name;

    for ( TInt i = 0; i < iObjectList->Count(); i++ )

        {

        name.Copy( iObjectList->At( i ).iName );

        item.Format( KLineFormatSpec, &name );

        iItems->AppendL( item );

        }

    // Set up list box

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

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

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

    }

TBool CMemSpyViewKernelObjects::HandleCommandL( TInt aCommand )

    {

    TBool handled = ETrue;

    //

    switch ( aCommand )

        {

        case EMemSpyCmdKernelObjectTerminate:

            {

            TRAPD( err, OnCmdTerminateL() );

            if ( err )

                {

                CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote( ETrue );

                note->ExecuteLD( _L("Cannot terminate task") );

                }

            break;

            }

        case EMemSpyCmdKernelObjectSwitchTo:

            {

            TRAPD( err, OnCmdSwitchToL() );

            if ( err )

                {

                CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote( ETrue );

                note->ExecuteLD( _L("Cannot bring to foreground") );

                }

            break;

            }

        case EMemSpyCmdKernelObjectEnd:

            {

            TRAPD( err, OnCmdEndL() );

            if ( err )

                {

                CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote( ETrue );

                note->ExecuteLD( _L("Cannot end task") );

                }

            break;

            }

        case EMemSpyCmdKernelObjectPanic:

            {

            TRAPD( err, OnCmdPanicL() );

            if ( err )

                {

                CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote( ETrue );

                note->ExecuteLD( _L("Cannot panic task") );

                }

            break;

            }

        default:

            {

            handled = CMemSpyViewBase::HandleCommandL( aCommand );

            break;        

            }

        }

    //

    return handled;

    }

TKeyResponse CMemSpyViewKernelObjects::OfferKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    TKeyResponse resp = EKeyWasNotConsumed;

    if  ( iTabs && ( aKeyEvent.iScanCode == EStdKeyRightArrow || aKeyEvent.iScanCode == EStdKeyLeftArrow ) )

        {

        resp = iTabs->OfferKeyEventL( aKeyEvent, aType );

        }

    else

        {

        resp = CMemSpyViewBase::OfferKeyEventL( aKeyEvent, aType );    

        }

    return resp;

    }

void CMemSpyViewKernelObjects::TabChangedL( TInt /*aIndex*/ )

    {

    iObjectType = (TMemSpyDriverContainerType)iTabs->ActiveTabId();

    RefreshL();

    }

void CMemSpyViewKernelObjects::OnCmdTerminateL()

    {

    switch ( iObjectType )

        {

        case EMemSpyDriverContainerTypeThread:

            {

            TBool doTerminate = ETrue;

            CMemSpyEngineObjectContainer& container = iEngine.Container();

            TThreadId id( iObjectList->At( iListBox->CurrentItemIndex() ).iId );

            // Try to find the thread in question...

            CMemSpyProcess* process = NULL;

            CMemSpyThread* thread = NULL; 

            User::LeaveIfError( container.ProcessAndThreadByThreadId( id, process, thread ) );

            if ( thread )

                {

                thread->Open();

                //

                if  ( thread->IsSystemPermanent() || thread->IsSystemCritical() )

                    {

                    CAknQueryDialog* importDialog = CAknQueryDialog::NewL();

                    doTerminate = ( importDialog->ExecuteLD( R_MEMSPY_PANIC_SYSTEM_CRITICAL_THREAD_OR_PROCESS ) );

                    }

                //

                if  ( doTerminate )

                    {

                    thread->TerminateL();

                    }                

                }

            RefreshL();

            break;

            }

        case EMemSpyDriverContainerTypeProcess:

            {

            TBool doTerminate = ETrue;

            // Obtain the process that corresponds to the selected item

            CMemSpyEngineObjectContainer& container = iEngine.Container();

            TProcessId id( iObjectList->At( iListBox->CurrentItemIndex() ).iId );

            CMemSpyProcess& process = container.ProcessByIdL( id );

            process.Open();

            if  ( process.IsSystemPermanent() || process.IsSystemCritical() )

                {

                CAknQueryDialog* importDialog = CAknQueryDialog::NewL();

                doTerminate = ( importDialog->ExecuteLD( R_MEMSPY_PANIC_SYSTEM_CRITICAL_THREAD_OR_PROCESS ) );

                }

            //

            if  ( doTerminate )

                {

                process.TerminateL();

                RefreshL();

                }

            break;

            }

        default:

            {

            // Programming error

            __ASSERT_ALWAYS( EFalse, User::Panic( _L("MemSpy-View"), 0 ) );

            }

        }

    }

void CMemSpyViewKernelObjects::OnCmdSwitchToL()

    {

    TInt wgCount;

    RWsSession wsSession;

    User::LeaveIfError( wsSession.Connect() );

    CleanupClosePushL( wsSession );

    User::LeaveIfError( wgCount = wsSession.NumWindowGroups() );

    RArray<RWsSession::TWindowGroupChainInfo> wgArray;

    CleanupClosePushL( wgArray );

    User::LeaveIfError( wsSession.WindowGroupList( &wgArray ) );

    TApaTask task( wsSession );

    TBool brought( EFalse );

    TInt wgId( KErrNotFound );

    TThreadId threadId;

    switch ( iObjectType )

        {

        case EMemSpyDriverContainerTypeThread:

            {

            TThreadId currentThreadId( iObjectList->At( iListBox->CurrentItemIndex() ).iId );

            // loop trough all window groups and see if a thread id matches

            while( !brought && wgCount-- )

                {

                wgId = wgArray[wgCount].iId;

                User::LeaveIfError( wsSession.GetWindowGroupClientThreadId( wgId, threadId ) );

                if ( threadId == currentThreadId )

                    {

                    CApaWindowGroupName* wgName = CApaWindowGroupName::NewLC( wsSession, wgId );

                    task.SetWgId( wgId );

                    if ( !wgName->Hidden() && task.Exists() )

                        {

                        task.BringToForeground();

                        brought = ETrue;                        

                        }

                    CleanupStack::PopAndDestroy( wgName );

                    }

                }                

            break;

            }

        case EMemSpyDriverContainerTypeProcess:

            {

            CMemSpyEngineObjectContainer& container = iEngine.Container();

            TProcessId id( iObjectList->At( iListBox->CurrentItemIndex() ).iId );

            CMemSpyProcess& process = container.ProcessByIdL( id );

            // loop trough threads in a process

            for ( TInt i = 0; i < process.MdcaCount(); i++ )

                {

                TInt wgCountLocal = wgCount;

                // loop trough all window groups and see if a thread id matches

                while( !brought && wgCountLocal-- )

                    {

                    wgId = wgArray[wgCountLocal].iId;

                    User::LeaveIfError( wsSession.GetWindowGroupClientThreadId( wgId, threadId ) );

                    if ( threadId == process.At( i ).Id() )

                        {

                        CApaWindowGroupName* wgName = CApaWindowGroupName::NewLC( wsSession, wgId );

                        task.SetWgId( wgId );

                        if ( !wgName->Hidden() && task.Exists() )

                            {

                            task.BringToForeground();

                            brought = ETrue;                        

                            }

                        CleanupStack::PopAndDestroy( wgName );

                        }

                    }

                }

            break;

            }

        default:

            {

            // Programming error

            __ASSERT_ALWAYS( EFalse, User::Panic( _L("MemSpy-View"), 0 ) );

            }

        }

    if ( !brought )

        {

        // Error handling in HandleCommandL

        User::Leave( KErrGeneral );

        }

    CleanupStack::PopAndDestroy( 2 ); //wgArray,wsSession

    }

void CMemSpyViewKernelObjects::OnCmdEndL()

    {

    switch ( iObjectType )

        {

        case EMemSpyDriverContainerTypeThread:

            {

            TBool doTerminate = ETrue;

            CMemSpyEngineObjectContainer& container = iEngine.Container();

            TThreadId id( iObjectList->At( iListBox->CurrentItemIndex() ).iId );

            // Try to find the thread in question...

            CMemSpyProcess* process = NULL;

            CMemSpyThread* thread = NULL; 

            User::LeaveIfError( container.ProcessAndThreadByThreadId( id, process, thread ) );

            if ( thread )

                {

                thread->Open();

                //

                if  ( thread->IsSystemPermanent() || thread->IsSystemCritical() )

                    {

                    CAknQueryDialog* importDialog = CAknQueryDialog::NewL();

                    doTerminate = ( importDialog->ExecuteLD( R_MEMSPY_PANIC_SYSTEM_CRITICAL_THREAD_OR_PROCESS ) );

                    }

                //

                if  ( doTerminate )

                    {

                    thread->KillL();

                    }                

                }

            RefreshL();

            break;

            }

        case EMemSpyDriverContainerTypeProcess:

            {

            TBool doTerminate = ETrue;

            // Obtain the process that corresponds to the selected item

            CMemSpyEngineObjectContainer& container = iEngine.Container();

            TProcessId id( iObjectList->At( iListBox->CurrentItemIndex() ).iId );

            CMemSpyProcess& process = container.ProcessByIdL( id );

            process.Open();

            if  ( process.IsSystemPermanent() || process.IsSystemCritical() )

                {

                CAknQueryDialog* importDialog = CAknQueryDialog::NewL();

                doTerminate = ( importDialog->ExecuteLD( R_MEMSPY_PANIC_SYSTEM_CRITICAL_THREAD_OR_PROCESS ) );

                }

            if  ( doTerminate )

                {

                process.KillL();

                RefreshL();

                }

            break;

            }

        default:

            {

            // Programming error

            __ASSERT_ALWAYS( EFalse, User::Panic( _L("MemSpy-View"), 0 ) );

            }

        }    

    }

void CMemSpyViewKernelObjects::OnCmdPanicL()

    {

    switch ( iObjectType )

        {

        case EMemSpyDriverContainerTypeThread:

            {

            TBool doTerminate = ETrue;

            CMemSpyEngineObjectContainer& container = iEngine.Container();

            TThreadId id( iObjectList->At( iListBox->CurrentItemIndex() ).iId );

            // Try to find the thread in question...

            CMemSpyProcess* process = NULL;

            CMemSpyThread* thread = NULL; 

            User::LeaveIfError( container.ProcessAndThreadByThreadId( id, process, thread ) );

            if ( thread )

                {

                thread->Open();

                //

                if  ( thread->IsSystemPermanent() || thread->IsSystemCritical() )

                    {

                    CAknQueryDialog* importDialog = CAknQueryDialog::NewL();

                    doTerminate = ( importDialog->ExecuteLD( R_MEMSPY_PANIC_SYSTEM_CRITICAL_THREAD_OR_PROCESS ) );

                    }

                //

                if  ( doTerminate )

                    {

                    thread->PanicL();

                    }                

                }

            RefreshL();

            break;

            }

        case EMemSpyDriverContainerTypeProcess:

            {

            TBool doTerminate = ETrue;

            // Obtain the process that corresponds to the selected item

            CMemSpyEngineObjectContainer& container = iEngine.Container();

            TProcessId id( iObjectList->At( iListBox->CurrentItemIndex() ).iId );

            CMemSpyProcess& process = container.ProcessByIdL( id );

            process.Open();