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

// System includes
#include <AknWaitDialog.h>
#include <memspyui.rsg>

// 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/memspyenginehelperprocess.h>

// User includes
#include "MemSpyContainerObserver.h"
#include "MemSpyViewThreadInfoItemList.h"

// Constants
const TInt KMemSpyConstructionCheckerTimerPeriod = 500000; // 1/2 second



CMemSpyViewThreadInfoItemGeneric::CMemSpyViewThreadInfoItemGeneric( CMemSpyEngine& aEngine, MMemSpyViewObserver& aObserver, CMemSpyThreadInfoContainer& aInfoContainer, TMemSpyThreadInfoItemType aType )
:   CMemSpyViewBase( aEngine, aObserver ), iContainer( aInfoContainer )
    {
    iContainer.Thread().Process().Open();
    iContainer.Thread().Open();
    iContainer.Open();
    //
    iInfoItem = &iContainer.Item( aType );
    __ASSERT_ALWAYS( iInfoItem != NULL, User::Invariant() );
    iInfoItem->Open();
    }


CMemSpyViewThreadInfoItemGeneric::~CMemSpyViewThreadInfoItemGeneric()
    {
    if  ( iInfoItem )
        {
        iInfoItem->Close();
        }
    //
    DestroyWaitNote();
    //
    iContainer.Close();
    iContainer.Thread().Close();
    iContainer.Thread().Process().Close();
    }


void CMemSpyViewThreadInfoItemGeneric::ConstructL( const TRect& aRect, CCoeControl& aContainer, TAny* aSelectionRune )
    {
    const TPtrC pTitle( iInfoItem->Name().Mid( 1 ) );
    SetTitleL( pTitle );
    //
    if  ( iInfoItem->IsReady() == EFalse )
        {
#ifdef _DEBUG
        RDebug::Printf( "CMemSpyViewThreadInfoItemGeneric::ConstructL() - show wait note - item not ready, iType: %d", iInfoItem->Type() );
#endif

        // Wait for engine data to be made ready... 
        ShowWaitNoteL();
        }

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


CMemSpyProcess& CMemSpyViewThreadInfoItemGeneric::Process() const
    {
    return iContainer.Thread().Process();
    }


CMemSpyThread& CMemSpyViewThreadInfoItemGeneric::Thread() const
    {
    return iContainer.Thread();
    }


CMemSpyThreadInfoContainer& CMemSpyViewThreadInfoItemGeneric::Container() const
    {
    return iContainer;
    }


CMemSpyThreadInfoItemBase& CMemSpyViewThreadInfoItemGeneric::InfoItem() const
    {
    __ASSERT_ALWAYS( iInfoItem != NULL, User::Invariant() );
    return *iInfoItem;
    }


void CMemSpyViewThreadInfoItemGeneric::RefreshL()
    {
    iInfoItem->RebuildL();    
    SetListBoxModelL();
    CMemSpyViewBase::RefreshL();
    }


TMemSpyViewType CMemSpyViewThreadInfoItemGeneric::ViewType() const
    {
    TMemSpyViewType type = EMemSpyViewTypeNone;
    //
    switch( iInfoItem->Type() )
        {
    case EMemSpyThreadInfoItemTypeHeap:
        type = EMemSpyViewTypeThreadInfoItemHeap;
        break;
    case EMemSpyThreadInfoItemTypeStack:
        type = EMemSpyViewTypeThreadInfoItemStack;
        break;
    case EMemSpyThreadInfoItemTypeChunk:
        type = EMemSpyViewTypeThreadInfoItemChunk;
        break;
    case EMemSpyThreadInfoItemTypeCodeSeg:
        type = EMemSpyViewTypeThreadInfoItemCodeSeg;
        break;
    case EMemSpyThreadInfoItemTypeServer:
        type = EMemSpyViewTypeThreadInfoItemServer;
        break;
    case EMemSpyThreadInfoItemTypeSession:
        type = EMemSpyViewTypeThreadInfoItemSession;
        break;
    case EMemSpyThreadInfoItemTypeSemaphore:
        type = EMemSpyViewTypeThreadInfoItemSemaphore;
        break;
    case EMemSpyThreadInfoItemTypeMutex:
        type = EMemSpyViewTypeThreadInfoItemMutex;
        break;
    case EMemSpyThreadInfoItemTypeTimer:
        type = EMemSpyViewTypeThreadInfoItemTimer;
        break;
    case EMemSpyThreadInfoItemTypeLDD:
        type = EMemSpyViewTypeThreadInfoItemLDD;
        break;
    case EMemSpyThreadInfoItemTypePDD:
        type = EMemSpyViewTypeThreadInfoItemPDD;
        break;
    case EMemSpyThreadInfoItemTypeLogicalChannel:
        type = EMemSpyViewTypeThreadInfoItemLogicalChannel;
        break;
    case EMemSpyThreadInfoItemTypeChangeNotifier:
        type = EMemSpyViewTypeThreadInfoItemChangeNotifier;
        break;
    case EMemSpyThreadInfoItemTypeUndertaker:
        type = EMemSpyViewTypeThreadInfoItemUndertaker;
        break;
    case EMemSpyThreadInfoItemTypeMessageQueue:
        type = EMemSpyViewTypeThreadInfoItemMessageQueue;
        break;
    case EMemSpyThreadInfoItemTypeConditionalVariable:
        type = EMemSpyViewTypeThreadInfoItemConditionalVariable;
        break;
    case EMemSpyThreadInfoItemTypeOpenFiles:
        type = EMemSpyViewTypeThreadInfoItemOpenFiles;
        break;
    case EMemSpyThreadInfoItemTypeActiveObject:
        type = EMemSpyViewTypeThreadInfoItemActiveObject;
        break;
    case EMemSpyThreadInfoItemTypeGeneralInfo:
        type = EMemSpyViewTypeThreadInfoItemGeneralInfo;
        break;
    case EMemSpyThreadInfoItemTypeOtherThreads:
        type = EMemSpyViewTypeThreadInfoItemOtherThreads;
        break;
    case EMemSpyThreadInfoItemTypeOtherProcesses:
        type = EMemSpyViewTypeThreadInfoItemOtherProcesses;
        break;
    case EMemSpyThreadInfoItemTypeOwnedThreadHandles:
        type = EMemSpyViewTypeThreadInfoItemOwnedThreadHandles;
        break;
    case EMemSpyThreadInfoItemTypeOwnedProcessHandles:
        type = EMemSpyViewTypeThreadInfoItemOwnedProcessHandles;
        break;

    default:
        __ASSERT_DEBUG( EFalse, User::Invariant() );
        break;
        }
    //
    return type;
    }


CMemSpyViewBase* CMemSpyViewThreadInfoItemGeneric::PrepareParentViewL()
    {
    CMemSpyViewThreadInfoItemList* parent = new(ELeave) CMemSpyViewThreadInfoItemList( iEngine, iObserver, Thread() );
    CleanupStack::PushL( parent );
    parent->ConstructL( Rect(), *Parent(), iInfoItem );
    CleanupStack::Pop( parent );
    return parent;
    }


CMemSpyViewBase* CMemSpyViewThreadInfoItemGeneric::PrepareChildViewL()
    {
    __ASSERT_ALWAYS( iInfoItem != NULL, User::Invariant() );
    CMemSpyViewBase* child = NULL;
    //
    return child;
    }


TBool CMemSpyViewThreadInfoItemGeneric::HandleCommandL( TInt aCommand )
    {
    TBool handled = CMemSpyViewBase::HandleCommandL( aCommand );
    return handled;
    }


void CMemSpyViewThreadInfoItemGeneric::SetListBoxModelL()
    {
    CAknSettingStyleListBox* listbox = static_cast< CAknSettingStyleListBox* >( iListBox );
    listbox->Model()->SetItemTextArray( iInfoItem );
    listbox->Model()->SetOwnershipType( ELbmDoesNotOwnItemArray );
    }


void CMemSpyViewThreadInfoItemGeneric::HandleListBoxItemActionedL( TInt /*aIndex*/ )
    {
    // Notify observer about an item being 'fired'
    ReportEventL( MMemSpyViewObserver::EEventItemActioned );
    }


void CMemSpyViewThreadInfoItemGeneric::HandleListBoxItemSelectedL( TInt /*aIndex*/ )
    {
    // Notify observer about item selection
    ReportEventL( MMemSpyViewObserver::EEventItemSelected );
    }



void CMemSpyViewThreadInfoItemGeneric::ShowWaitNoteL()
    {
    // Ugly, but I'm not adding an observer mechanism just for this wait dialog.
    __ASSERT_ALWAYS( iWaitConstructionChecker == NULL, User::Invariant() );
    iWaitConstructionChecker = CPeriodic::NewL( CActive::EPriorityLow );
    iWaitConstructionChecker->Start( KMemSpyConstructionCheckerTimerPeriod, 
                                     KMemSpyConstructionCheckerTimerPeriod, 
                                     TCallBack( CheckForItemConstructionComplete, this ) );

    if  ( !iWaitNote )
        {
        iWaitNote = new ( ELeave ) CAknWaitDialog( reinterpret_cast<CEikDialog**> ( &iWaitNote ), ETrue );
        iWaitNote->ExecuteDlgLD( CAknNoteDialog::ENoTone, R_MEMSPY_PREPARING_INFO_ITEM_CONTAINER_WAIT_NOTE );
        }
    }


void CMemSpyViewThreadInfoItemGeneric::DestroyWaitNote()
    {
#ifdef _DEBUG
    RDebug::Printf( "CMemSpyViewThreadInfoItemGeneric::DestroyWaitNote() - START" );
#endif
	//
    delete iWaitConstructionChecker;
    iWaitConstructionChecker = NULL;
    //
    if  ( iWaitNote )
        {
        TRAP_IGNORE( iWaitNote->ProcessFinishedL() ); // deletes the dialog
        iWaitNote = NULL;
        }
	//
#ifdef _DEBUG
    RDebug::Printf( "CMemSpyViewThreadInfoItemGeneric::DestroyWaitNote() - END" );
#endif
    }


TInt CMemSpyViewThreadInfoItemGeneric::CheckForItemConstructionComplete( TAny* aSelf )
    {
    CMemSpyViewThreadInfoItemGeneric& self = *reinterpret_cast< CMemSpyViewThreadInfoItemGeneric* >( aSelf );
    //
#ifdef _DEBUG
    RDebug::Printf( "CMemSpyViewThreadInfoItemGeneric::CheckForItemConstructionComplete() - ready status: %d, iType: %d", self.iInfoItem->IsReady(), self.iInfoItem->Type() );
#endif
	//
    TBool callAgain = ETrue;
    if  ( self.iInfoItem->IsReady() )
        {
        self.DestroyWaitNote();
        callAgain = EFalse;
        }
    //
    return callAgain;
    }