/*

* 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>

#include <memspysession.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( RMemSpySession& aSession, MMemSpyViewObserver& aObserver, TMemSpyDriverContainerType aObjectType )

:   CMemSpyViewBase( aSession, 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 ( iNaviPane && iNavDecorator )

	   {

		iNaviPane->Pop( iNavDecorator );

		delete iNavDecorator;

		iNavDecorator = NULL;

	   }	

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

    CMemSpyViewBase* parent = new(ELeave) CMemSpyViewKernelContainers( iMemSpySession, 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" );

    _LIT( KTab, "\t" );

    iMemSpySession.GetKernelObjectItems( iKernelObjectItems, iObjectType );

    iModel = new (ELeave) CDesC16ArrayFlat( iKernelObjectItems.Count() ); //array for formated items

    for ( TInt i = 0; i < iKernelObjectItems.Count(); i++ )

    	{

		HBufC* tempName = HBufC::NewL( iKernelObjectItems[i]->Name().Length() + 16 );

    	CleanupStack::PushL( tempName );

    	TPtr tempNamePtr( tempName->Des() );

    	tempNamePtr.Copy( KTab );

    	tempNamePtr.Append( iKernelObjectItems[i]->Name() );

    	iModel->AppendL( tempNamePtr );

    	CleanupStack::PopAndDestroy( tempName ); 

    	}

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

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

    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 )

    {

	// TODO: to remove support of tabs

    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*/ )

    {

	/* TODO: tabs removed

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

            TThreadId id( iKernelObjectItems[ iListBox->CurrentItemIndex() ]->Id() ); //get id of the current thread

            TBool err;

            iMemSpySession.ThreadSystemPermanentOrCritical( id, err );

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

            //CMemSpyProcess* process = NULL;

            //CMemSpyThread* thread = NULL; 

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

            if( err )

            	{

				CAknQueryDialog* importDialog = CAknQueryDialog::NewL();

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

				if ( doTerminate )

					{

					iMemSpySession.TerminateThread( id );

					}

            	}            

            /*

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

            TProcessId id( iKernelObjectItems[ iListBox->CurrentItemIndex() ]->Id() );

            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();