// ResultsPaneView.cpp : implementation file
//
// Copyright (c) 2000 Microsoft Corporation
//
// 03/30/00 v-marfin 59644 : GetUpperPaneSelectedCount(). Created to get the number of selected items so we can pass it 
//                           to the context menu so it knows whether to add the
//                           third party menu item "TroubleShooting" which it should
//                           only add if there is only 1 item selected.
// 04/02/00 v-marfin 59643b  On creation of new objects, show details page first.
//
//
//
#include "stdafx.h"
#include "snapin.h"
#include "ResultsPaneView.h"
#include "ScopePane.h"
#include "ResultsPane.h"

#include "HealthmonResultsPane.h"
#include "HMListView.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CResultsPaneView

IMPLEMENT_DYNCREATE(CResultsPaneView, CCmdTarget)

CResultsPaneView::CResultsPaneView()
{
	EnableAutomation();

	m_pOwnerScopeItem = NULL;
}

CResultsPaneView::~CResultsPaneView()
{
	Destroy();
}

/////////////////////////////////////////////////////////////////////////////
// Create/Destroy

bool CResultsPaneView::Create(CScopePaneItem* pOwnerItem)
{
	TRACEX(_T("CResultsPaneView::Create\n"));
	TRACEARGn(pOwnerItem);

	if( ! GfxCheckObjPtr(pOwnerItem,CScopePaneItem) )
	{
		TRACE(_T("FAILED : pOwnerItem is not a valid pointer.\n"));
		return false;
	}

	SetOwnerScopeItem(pOwnerItem);

	return true;
}

void CResultsPaneView::Destroy()
{
	TRACEX(_T("CResultsPaneView::Destroy\n"));

  RemoveAllItems();

	m_pOwnerScopeItem = NULL;

  for( int i=0; i < m_Columns.GetSize(); i++ )
  {
    delete m_Columns[i];
  }
  m_Columns.RemoveAll();

	m_ResultsPanes.RemoveAll();

}

/////////////////////////////////////////////////////////////////////////////
// Owner ScopeItem Members

CScopePaneItem* CResultsPaneView::GetOwnerScopeItem()
{
	TRACEX(_T("CResultsPaneView::GetOwnerScopeItem\n"));

	if( ! GfxCheckObjPtr(m_pOwnerScopeItem,CScopePaneItem) )
	{
		TRACE(_T("FAILED : m_pOwnerScopeItem is not a valid pointer.\n"));
		return NULL;
	}

	return m_pOwnerScopeItem;
}

void CResultsPaneView::SetOwnerScopeItem(CScopePaneItem* pOwnerItem)
{
	TRACEX(_T("CResultsPaneView::SetOwnerScopeItem\n"));
	TRACEARGn(pOwnerItem);

	if( ! GfxCheckObjPtr(pOwnerItem,CScopePaneItem) )
	{
		TRACE(_T("FAILED : pOwnerItem is not a valid pointer.\n"));
		return;
	}

	m_pOwnerScopeItem = pOwnerItem;
}


/////////////////////////////////////////////////////////////////////////////
// ListView Column Members

int CResultsPaneView::GetColumnCount() const
{
	TRACEX(_T("CResultsPaneView::GetColumnCount\n"));

	return (int)m_Columns.GetSize();
}

CListViewColumn* CResultsPaneView::GetColumn(int iIndex)
{
	TRACEX(_T("CResultsPaneView::GetColumn\n"));
	TRACEARGn(iIndex);

	if( iIndex >= m_Columns.GetSize() || iIndex < 0 )
	{
		TRACE(_T("FAILED : iIndex is out of array bounds.\n"));
		return NULL;
	}

	return m_Columns[iIndex];
}

void CResultsPaneView::SetColumn(int iIndex, CListViewColumn* pColumn)
{
	TRACEX(_T("CResultsPaneView::SetColumn\n"));
	TRACEARGn(iIndex);
	TRACEARGn(pColumn);

	if( iIndex >= m_Columns.GetSize() || iIndex < 0 )
	{
		TRACE(_T("FAILED : iIndex is out of array bounds.\n"));
		return;
	}

	if( ! GfxCheckObjPtr(pColumn,CListViewColumn) )
	{
		TRACE(_T("FAILED : pColumn is not a valid pointer.\n"));
		return;
	}

	m_Columns.SetAt(iIndex,pColumn);
}

int CResultsPaneView::AddColumn(CListViewColumn* pColumn)
{
	TRACEX(_T("CResultsPaneView::AddColumn\n"));
	TRACEARGn(pColumn);

	if( ! GfxCheckObjPtr(pColumn,CListViewColumn) )
	{
		TRACE(_T("FAILED : pColumn is not a valid pointer.\n"));
		return -1;
	}

	return (int)m_Columns.Add(pColumn);
}

void CResultsPaneView::RemoveColumn(int iIndex)
{
	TRACEX(_T("CResultsPaneView::RemoveColumn\n"));
	TRACEARGn(iIndex);

	if( iIndex >= m_Columns.GetSize() || iIndex < 0 )
	{
		TRACE(_T("FAILED : iIndex is out of array bounds.\n"));
		return;
	}
	
	delete m_Columns[iIndex];
	m_Columns.RemoveAt(iIndex);
}


/////////////////////////////////////////////////////////////////////////////
// Results Pane Item Members

int CResultsPaneView::GetItemCount() const
{
	TRACEX(_T("CResultsPaneView::GetItemCount\n"));

	return (int)m_ResultItems.GetSize();
}

CResultsPaneItem* CResultsPaneView::GetItem(int iIndex)
{
	TRACEX(_T("CResultsPaneView::GetItem\n"));
	TRACEARGn(iIndex);

	if( iIndex >= m_ResultItems.GetSize() || iIndex < 0 )
	{
		TRACE(_T("FAILED : iIndex is out of array bounds.\n"));
		return NULL;
	}

	if( ! GfxCheckObjPtr(m_ResultItems[iIndex],CResultsPaneItem) )
	{
		TRACE(_T("FAILED : item pointer at iIndex is invalid.\n"));
		return NULL;
	}
	
	return m_ResultItems[iIndex];
}

int CResultsPaneView::AddItem(CResultsPaneItem* pItem, bool bResizeColumn /*= false*/)
{
	TRACEX(_T("CResultsPaneView::AddItem\n"));
	TRACEARGn(pItem);

	if( ! GfxCheckObjPtr(pItem,CResultsPaneItem) )
	{
		TRACE(_T("FAILED : pItem is not a valid pointer.\n"));
		return -1;
	}

	int iNewItemIndex = (int)m_ResultItems.Add(pItem);

	ASSERT(iNewItemIndex != -1);

	// for all result panes on this view, add the item into each pane
	for( int i = 0; i < m_ResultsPanes.GetSize(); i++ )	
	{
		if( ! pItem->InsertItem(m_ResultsPanes[i],0, bResizeColumn) )
		{
			TRACE(_T("FAILED : CResultsPaneItem::InsertItem failed.\n"));
			ASSERT(FALSE);			
		}
	}

	return iNewItemIndex;
}

void CResultsPaneView::RemoveItem(int iIndex)
{
	TRACEX(_T("CResultsPaneView::RemoveItem\n"));
	TRACEARGn(iIndex);

	if( iIndex >= m_ResultItems.GetSize() || iIndex < 0 )
	{
		TRACE(_T("FAILED : iIndex is out of array bounds.\n"));
		return;
	}

	CResultsPaneItem* pItem = m_ResultItems[iIndex];

	if( ! GfxCheckObjPtr(pItem,CResultsPaneItem) )
	{
		TRACE(_T("FAILED : pItem is not a valid results pane item pointer.\n"));
		return;
	}

	// for each pane showing this results view, delete the item from it
	// this gets a little ugly...sorry
	for( int i=0; i < m_ResultsPanes.GetSize(); i++ )
	{
		if( GfxCheckObjPtr(m_ResultsPanes[i],CResultsPane) )
		{
			LPRESULTDATA lpResultData = m_ResultsPanes[i]->GetResultDataPtr();

			if( lpResultData )
			{
				HRESULTITEM hri = NULL;

				if( lpResultData->FindItemByLParam((LPARAM)pItem,&hri) == S_OK )
				{
					HRESULT hr = lpResultData->DeleteItem(hri,0);
					if( ! CHECKHRESULT(hr) )
					{
						TRACE(_T("FAILED : IResultData::DeleteItem failed.\n"));
					}					
				}

				lpResultData->Release();
			}
		}
	}

	delete pItem;
	m_ResultItems.RemoveAt(iIndex);
}

void CResultsPaneView::RemoveItem(CResultsPaneItem* pItem)
{
	TRACEX(_T("CResultsPaneView::RemoveItem\n"));
	TRACEARGn(pItem);

	if( ! GfxCheckObjPtr(pItem,CResultsPaneItem) )
	{
		TRACE(_T("FAILED : pItem is not a valid pointer.\n"));
		return;
	}

	for( int i = 0; i < m_ResultItems.GetSize(); i++ )
	{
		if( pItem == m_ResultItems[i] )
		{
			RemoveItem(i);
			return;
		}
	}
}

void CResultsPaneView::RemoveItem(const CString& sName)
{
	TRACEX(_T("CResultsPaneView::RemoveItem\n"));

	if( sName.IsEmpty() )
	{
		TRACE(_T("FAILED : sName is empty.\n"));
		return;
	}

	for( int i = 0; i < m_ResultItems.GetSize(); i++ )
	{
		if( GfxCheckObjPtr(m_ResultItems[i],CResultsPaneItem) )
		{
			if( sName == m_ResultItems[i]->GetDisplayName() )
			{
				RemoveItem(i);
				return;
			}
		}
	}
}

int CResultsPaneView::FindItem(RPIFINDPROC pFindProc, LPARAM param)
{
	TRACEX(_T("CResultsPaneView::FindItem\n"));
	TRACEARGn(pFindProc);
	TRACEARGn(param);

	if( ! GfxCheckPtr(pFindProc,RPIFINDPROC) )
	{
		TRACE(_T("FAILED : pFindProc is not a valid function pointer.\n"));
		return -1;
	}

	return pFindProc(m_ResultItems,param);
}

bool CResultsPaneView::UpdateItem(CResultsPaneItem* pItem)
{
	TRACEX(_T("CResultsPaneView::UpdateItem\n"));
	TRACEARGn(pItem);
	
  if( ! GfxCheckObjPtr(pItem,CResultsPaneItem) )
  {
    TRACE(_T("FAILED : pItem is not a valid pointer.\n"));
    return false;
  }

  HRESULT hr = S_OK;

	for( int i=0; i < m_ResultsPanes.GetSize(); i++ )
	{
		hr = pItem->SetItem(m_ResultsPanes[i]);
		if( hr == S_FALSE || ! CHECKHRESULT(hr) )
		{
			TRACE(_T("FAILED : CResultsPaneItem::SetItem failed.\n"));
		}
	}

	return true;
}

void CResultsPaneView::UpdateAllItems()
{
	TRACEX(_T("CResultsPaneView::UpdateAllItems\n"));

	for( int i = 0; i < m_ResultItems.GetSize(); i++ )
	{
		if( ! UpdateItem(m_ResultItems[i]) )
		{
			TRACE(_T("FAILED : CResultsPaneView::UpdateItem failed.\n"));
		}
	}
}

void CResultsPaneView::RemoveAllItems()
{
	TRACEX(_T("CResultsPaneView::RemoveAllItems\n"));

	for( int i = (int)m_ResultItems.GetSize()-1; i >=0 ; i-- )
	{
		RemoveItem(i);
	}
}

bool CResultsPaneView::GetSelectedItems(ResultsPaneItemArray& rpiaSelectedItems)
{
	TRACEX(_T("CResultsPaneView::GetSelectedItems\n"));
	TRACEARGn(rpiaSelectedItems.GetSize());

	return true;
}

int CResultsPaneView::GetUpperPaneSelectedCount()
{
	TRACEX(_T("CResultsPaneView::GetUpperPaneSelectedCount\n"));

    // v-marfin 59644 : Get the number of selected items so we can pass it 
    //                  to the context menu so it knows whether to add the
    //                  third party menu item "TroubleShooting" which it should
    //                  only add if there is only 1 item selected.
    if (m_ResultsPanes.GetSize() < 1)
    {
        TRACE(_T("ERROR: CResultsPaneView::GetUpperPaneSelectedCount(): no results panes defined.\n"));
        return 0;
    }

    CHealthmonResultsPane* pPane = (CHealthmonResultsPane*)m_ResultsPanes[0];
    if (!pPane)
    {
        TRACE(_T("ERROR: CResultsPaneView::GetUpperPaneSelectedCount() : Could not fetch CHealthmonResultsPane\n"));
        return 0;
    }

    _DHMListView* pList = pPane->GetUpperListCtrl();
    if (!pList)
    {
        TRACE(_T("ERROR: CResultsPaneView::GetUpperPaneSelectedCount() : Could not fetch upper list control\n"));
        return 0;
    }

    int nSelectedCount = pList->GetSelectedCount();

	return nSelectedCount;
}

/////////////////////////////////////////////////////////////////////////////
// Property Page Members

bool CResultsPaneView::IsPropertySheetOpen()
{
	TRACEX(_T("CResultsPaneView::IsPropertySheetOpen\n"));

	// this function attempts to bring up an open property sheet for each result item
	// if it succeeds, then the property sheet is brought to the foreground
	// if it fails, then there are no open property sheets for the results view

	if( ! GetOwnerScopeItem() || ! GetOwnerScopeItem()->GetScopePane() )
	{
		TRACE(_T("FAILED : Owner scope item is not a valid object.\n"));
		return false;
	}

	LPCONSOLE2 lpConsole = GetOwnerScopeItem()->GetScopePane()->GetConsolePtr();

	if( ! GfxCheckPtr(lpConsole,IConsole2) )
	{
		TRACE(_T("FAILED : lpConsole is not a valid pointer.\n"));
		return false;
	}

	// get a reference to the IPropertySheetProvider interface
	LPPROPERTYSHEETPROVIDER lpProvider = NULL;

	HRESULT hr = lpConsole->QueryInterface(IID_IPropertySheetProvider,(LPVOID*)&lpProvider);

	if( ! CHECKHRESULT(hr) )
	{
		TRACE(_T("IConsole2::QueryInterface failed.\n"));
		lpConsole->Release();
		return FALSE;
	}

	ASSERT(lpProvider);

	bool bIsOpenSheet = false;

	for( int i = 0; i < m_ResultItems.GetSize(); i++ )
	{
		// create an IDataObject for this result item
		CSnapinDataObject* pdoNew = NULL;
		pdoNew = new CSnapinDataObject;

		if( ! GfxCheckObjPtr(pdoNew,CSnapinDataObject) )
		{
			TRACE(_T("FAILED : Out of memory.\n"));
			lpProvider->Release();
			lpConsole->Release();
			return false;
		}

		LPDATAOBJECT lpDataObject = (LPDATAOBJECT)pdoNew->GetInterface(&IID_IDataObject);
		ASSERT(lpDataObject);
		pdoNew->SetItem(m_ResultItems[i]);

		for( int i = 0; i < GetOwnerScopeItem()->GetScopePane()->GetResultsPaneCount(); i++ )
		{
			CResultsPane* pResultsPane = GetOwnerScopeItem()->GetScopePane()->GetResultsPane(i);
			if( GfxCheckObjPtr(pResultsPane,CResultsPane) )
			{
				LPCOMPONENT lpComponent = (LPCOMPONENT)pResultsPane->GetInterface(&IID_IComponent);
				hr = lpProvider->FindPropertySheet(MMC_COOKIE(this),lpComponent,lpDataObject);
				if( hr == S_OK )
				{
					bIsOpenSheet = true;
				}
			}
		}

		delete pdoNew;

	}

	lpProvider->Release();
	lpConsole->Release();

	return bIsOpenSheet;
}

bool CResultsPaneView::InvokePropertySheet(CResultsPaneItem* pItem)
{
	TRACEX(_T("CResultsPaneView::InvokePropertySheet\n"));
	TRACEARGn(pItem);

	// first see if a property sheet for this item is open already
	if( IsPropertySheetOpen() )
	{
		return true;
	}

	if( ! GetOwnerScopeItem() || ! GetOwnerScopeItem()->GetScopePane() )
	{
		TRACE(_T("FAILED : Owner scope item is not a valid object.\n"));
		return false;
	}

	LPCONSOLE2 lpConsole = GetOwnerScopeItem()->GetScopePane()->GetConsolePtr();

	if( ! GfxCheckPtr(lpConsole,IConsole2) )
	{
		TRACE(_T("FAILED : lpConsole is not a valid pointer.\n"));
		return false;
	}

	// get a reference to the IPropertySheetProvider interface
	LPPROPERTYSHEETPROVIDER lpProvider = NULL;

	HRESULT hr = lpConsole->QueryInterface(IID_IPropertySheetProvider,(LPVOID*)&lpProvider);

	if( ! CHECKHRESULT(hr) )
	{
		TRACE(_T("IConsole2::QueryInterface failed.\n"));
		lpConsole->Release();
		return FALSE;
	}

	ASSERT(lpProvider);

	// create an IDataObject for this result item
  CSnapinDataObject* pdoNew = NULL;
	pdoNew = new CSnapinDataObject;

	if( ! GfxCheckObjPtr(pdoNew,CSnapinDataObject) )
	{
		TRACE(_T("FAILED : Out of memory.\n"));
		lpProvider->Release();
		lpConsole->Release();
		return false;
	}

	LPDATAOBJECT lpDataObject = (LPDATAOBJECT)pdoNew->GetInterface(&IID_IDataObject);
	ASSERT(lpDataObject);
	pdoNew->SetItem(pItem);

	hr = lpProvider->CreatePropertySheet(pItem->GetDisplayName(),TRUE,MMC_COOKIE(pItem),lpDataObject,MMC_PSO_HASHELP);

	if( ! CHECKHRESULT(hr) )
	{
		TRACE(_T("FAILED : IPropertySheetProvider::CreatePropertySheet failed.\n"));
		lpProvider->Release();
		lpConsole->Release();

		delete pdoNew;

		return false;
	}

	HWND hWndNotification = NULL;
	HWND hWndMain = NULL;

	hr = lpConsole->GetMainWindow(&hWndMain);
	if( ! CHECKHRESULT(hr) )
	{
		// Release data allocated in CreatePropertySheet
		lpProvider->Show( -1, 0);
		lpProvider->Release();
		lpConsole->Release();
		
		delete pdoNew;

		return false;
	}

	// Try to get the correct window that notifications should be sent to.
	hWndNotification = FindWindowEx( hWndMain, NULL, _T("MDIClient"), NULL );
	hWndNotification = FindWindowEx( hWndNotification, NULL, _T("MMCChildFrm"), NULL );
	hWndNotification = FindWindowEx( hWndNotification, NULL, _T("MMCView"), NULL );
	
	if( hWndNotification == NULL )
	{
		// It was a nice try, but it failed, so we should be able to get by by using the main HWND.
		hWndNotification = hWndMain;
	}

	LPCOMPONENTDATA lpComponentData = (LPCOMPONENTDATA)GetOwnerScopeItem()->GetScopePane()->GetInterface(&IID_IComponentData);

	hr = lpProvider->AddPrimaryPages(lpComponentData,TRUE,hWndNotification,TRUE);
	if( ! CHECKHRESULT(hr) )
	{
		// Release data allocated in CreatePropertySheet
		lpProvider->Show(-1,0);
		lpProvider->Release();
		lpConsole->Release();

		delete pdoNew;

		return false;
	}

    hr = lpProvider->AddExtensionPages();  
	if( ! CHECKHRESULT(hr) )
	{
		// ISSUE: Should I care if this fails?

		// Release data allocated in CreatePropertySheet
		lpProvider->Show( -1, 0);
		lpProvider->Release();
		lpConsole->Release();

		delete pdoNew;

		return false;
	}

    // v-marfin : Show "details" page on creation of a new obejct
#ifndef IA64
    hr = lpProvider->Show( (long) hWndMain, 1);  // 59643b
#endif // IA64

	if( ! CHECKHRESULT( hr ) )
	{
		// Release data allocated in CreatePropertySheet
		lpProvider->Show( -1, 0);
		lpProvider->Release();
		lpConsole->Release();

		delete pdoNew;

		return false;
	}

	lpProvider->Release();
	lpConsole->Release();

	delete pdoNew;

	return true;
}

/////////////////////////////////////////////////////////////////////////////
// Context Menu Members

bool CResultsPaneView::InvokeContextMenu(const CPoint& pt, CResultsPaneItem* pItem, int iSelectedCount)
{
	TRACEX(_T("CResultsPaneView::InvokeContextMenu\n"));
	TRACEARGn(pt.x);
	TRACEARGn(pt.y);
	TRACEARGn(pItem);

	ASSERT(m_ResultsPanes.GetSize());

	CResultsPane* pPane = m_ResultsPanes[0];
	if( !pPane || ! GfxCheckObjPtr(pPane,CResultsPane) )
	{
		return false;
	}

	LPCONSOLE2 lpConsole = pPane->GetConsolePtr();

	// get a reference to the IContextMenuProvider interface
	LPCONTEXTMENUPROVIDER lpProvider = NULL;

	HRESULT hr = lpConsole->QueryInterface(IID_IContextMenuProvider,(LPVOID*)&lpProvider);

	if( ! CHECKHRESULT(hr) )
	{
		TRACE(_T("IConsole2::QueryInterface failed.\n"));
		lpConsole->Release();
		return FALSE;
	}

	ASSERT(lpProvider);

	// just as a precaution
	hr = lpProvider->EmptyMenuList();

	// populate the menu
	CONTEXTMENUITEM cmi;
  CString sResString;
  CString sResString2;
	ZeroMemory(&cmi,sizeof(CONTEXTMENUITEM));

	// add the top insertion point
	cmi.lCommandID = CCM_INSERTIONPOINTID_PRIMARY_TOP;
	cmi.lInsertionPointID = CCM_INSERTIONPOINTID_ROOT_MENU;
	cmi.fSpecialFlags = CCM_SPECIAL_INSERTION_POINT;

	hr = lpProvider->AddItem(&cmi);

	// add new menu and insertion point

  sResString.LoadString(IDS_STRING_NEW);
	cmi.strName           = LPTSTR(LPCTSTR(sResString));
  sResString2.LoadString(IDS_STRING_NEW_DESCRIPTION);
	cmi.strStatusBarText  = LPTSTR(LPCTSTR(sResString2));
	cmi.lCommandID = CCM_INSERTIONPOINTID_PRIMARY_NEW;
	cmi.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TOP;
	cmi.fFlags            = MF_POPUP;
	cmi.fSpecialFlags = CCM_SPECIAL_SUBMENU;

	hr = lpProvider->AddItem(&cmi);

	cmi.lCommandID = CCM_INSERTIONPOINTID_PRIMARY_NEW;
	cmi.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TOP;
	cmi.fSpecialFlags = CCM_SPECIAL_INSERTION_POINT;

	hr = lpProvider->AddItem(&cmi);

	// add task menu and insertion point

  sResString.LoadString(IDS_STRING_TASK);
	cmi.strName           = LPTSTR(LPCTSTR(sResString));
  sResString2.LoadString(IDS_STRING_TASK_DESCRIPTION);
	cmi.strStatusBarText  = LPTSTR(LPCTSTR(sResString2));
	cmi.lCommandID = CCM_INSERTIONPOINTID_PRIMARY_TASK;
	cmi.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TOP;
	cmi.fFlags            = MF_POPUP;
	cmi.fSpecialFlags = CCM_SPECIAL_SUBMENU;

	hr = lpProvider->AddItem(&cmi);

	cmi.lCommandID = CCM_INSERTIONPOINTID_PRIMARY_TASK;
	cmi.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TOP;
	cmi.fSpecialFlags = CCM_SPECIAL_INSERTION_POINT;

	hr = lpProvider->AddItem(&cmi);

	// create an IDataObject for this results item
  CSnapinDataObject* pdoNew = NULL;
	pdoNew = new CSnapinDataObject;

	if( ! GfxCheckObjPtr(pdoNew,CSnapinDataObject) )
	{
		TRACE(_T("FAILED : Out of memory.\n"));
		lpProvider->Release();
		lpConsole->Release();
		return false;
	}

	LPDATAOBJECT lpDataObject = (LPDATAOBJECT)pdoNew->GetInterface(&IID_IDataObject);
	ASSERT(lpDataObject);
	pdoNew->SetItem(pItem);

	LPUNKNOWN lpUnknown = (LPUNKNOWN)pPane->GetInterface(&IID_IExtendContextMenu);
	hr = lpProvider->AddPrimaryExtensionItems(lpUnknown,lpDataObject);

	// add third party insertion points only if there is 1 item selected
  if( iSelectedCount == 1 )
  {
	  cmi.lCommandID = CCM_INSERTIONPOINTID_3RDPARTY_NEW;
	  cmi.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_NEW;
	  cmi.fSpecialFlags = CCM_SPECIAL_INSERTION_POINT;

	  hr = lpProvider->AddItem(&cmi);

	  cmi.lCommandID = CCM_INSERTIONPOINTID_3RDPARTY_TASK;
	  cmi.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_TASK;
	  cmi.fSpecialFlags = CCM_SPECIAL_INSERTION_POINT;

	  hr = lpProvider->AddItem(&cmi);

	  hr = lpProvider->AddThirdPartyExtensionItems(lpDataObject);
  }

	HWND hWndMain = NULL;
	
	hr = lpConsole->GetMainWindow(&hWndMain);

	// Try to get the correct window that notifications should be sent to.
	HWND hWndNotification = FindWindowEx( hWndMain, NULL, _T("MDIClient"), NULL );
	hWndNotification = FindWindowEx( hWndNotification, NULL, _T("MMCChildFrm"), NULL );
	hWndNotification = FindWindowEx( hWndNotification, NULL, _T("AfxFrameOrView42u"), NULL );
	if( hWndNotification == NULL )
	{
		// It was a nice try, but it failed, so we should be able to get by by using the main HWND.
		hWndNotification = hWndMain;
	}	

	long lSelected = 0L;
	hr = lpProvider->ShowContextMenu(hWndNotification,pt.x,pt.y,&lSelected);

	lpProvider->Release();
	lpConsole->Release();

	lpDataObject->Release();

	return true;
}


/////////////////////////////////////////////////////////////////////////////
// Results Pane Members - tracks each results pane open on a particular results view

void CResultsPaneView::AddResultsPane(CResultsPane* pPane)
{
	TRACEX(_T("CResultsPaneView::AddResultsPane\n"));
	TRACEARGn(pPane);

	if( ! GfxCheckObjPtr(pPane,CResultsPane) )
	{
		TRACE(_T("FAILED : pPane is not a valid pointer.\n"));
		return;
	}

	m_ResultsPanes.Add(pPane);
}

void CResultsPaneView::RemoveResultsPane(CResultsPane* pPane)
{
	TRACEX(_T("CResultsPaneView::RemoveResultsPane\n"));
	TRACEARGn(pPane);

	if( ! GfxCheckObjPtr(pPane,CResultsPane) )
	{
		TRACE(_T("FAILED : pPane is not a valid pointer.\n"));
		return;
	}

	for( int i = 0; i < m_ResultsPanes.GetSize(); i++ )
	{
		if( m_ResultsPanes[i] == pPane )
		{
			m_ResultsPanes.RemoveAt(i);
			return;
		}
	} 
}

CResultsPane* CResultsPaneView::GetResultsPane(int iIndex)
{
	TRACEX(_T("CResultsPaneView::GetResultsPane\n"));
	TRACEARGn(iIndex);

	if( iIndex < 0 )
	{
		TRACE(_T("FAILED : index is out of bounds.\n"));
		return NULL;
	}

	if( iIndex > m_ResultsPanes.GetUpperBound() )
	{
		TRACE(_T("FAILED : index is out of bounds.\n"));
		return NULL;
	}
	
	return m_ResultsPanes[iIndex];
}

int CResultsPaneView::GetResultsPanesCount()
{
	TRACEX(_T("CResultsPaneView::GetResultsPanesCount\n"));

	return (int)m_ResultsPanes.GetSize();
}


/////////////////////////////////////////////////////////////////////////////
// MMC Notify Handlers

HRESULT CResultsPaneView::OnActivate(BOOL bActivate)
{
	TRACEX(_T("CResultsPaneView::OnActivate\n"));
	TRACEARGn(bActivate);

	return S_OK;
}

HRESULT CResultsPaneView::OnAddMenuItems(CResultsPaneItem* pItem, LPCONTEXTMENUCALLBACK piCallback,long __RPC_FAR *pInsertionAllowed)
{
	TRACEX(_T("CResultsPaneView::OnAddMenuItems\n"));
	TRACEARGn(pItem);
	TRACEARGn(piCallback);
	TRACEARGn(pInsertionAllowed);

  // Add New Menu Items
  if( CCM_INSERTIONALLOWED_NEW & *pInsertionAllowed )
  {
    // TODO: Add any context menu items for the New Menu here
  }

  // Add Task Menu Items
  if( CCM_INSERTIONALLOWED_TASK & *pInsertionAllowed )
  {
	  // TODO: Add any context menu items for the Task Menu here
  }

	return pItem->OnAddMenuItems(piCallback,pInsertionAllowed);
}

HRESULT CResultsPaneView::OnBtnClick(CResultsPaneItem* pItem, MMC_CONSOLE_VERB mcvVerb)
{
	TRACEX(_T("CResultsPaneView::OnBtnClick\n"));
	TRACEARGn(pItem);
	TRACEARGn(mcvVerb);

	return S_OK;
}

HRESULT CResultsPaneView::OnCommand(CResultsPane* pPane, CResultsPaneItem* pItem, long lCommandID)
{
	TRACEX(_T("CResultsPaneView::OnCommand\n"));
	TRACEARGn(pPane);
	TRACEARGn(pItem);
	TRACEARGn(lCommandID);

	return pItem->OnCommand(pPane,lCommandID);
}

HRESULT CResultsPaneView::OnContextHelp(CResultsPaneItem* pItem)
{
	TRACEX(_T("CResultsPaneView::OnContextHelp\n"));
	TRACEARGn(pItem);

	if( ! GetOwnerScopeItem() )
	{
		return E_FAIL;
	}

	return GetOwnerScopeItem()->OnContextHelp();
}

HRESULT CResultsPaneView::OnCreatePropertyPages(CResultsPaneItem* pItem, LPPROPERTYSHEETCALLBACK lpProvider, INT_PTR handle)
{
	TRACEX(_T("CResultsPaneView::OnCreatePropertyPages\n"));
	TRACEARGn(lpProvider);
	TRACEARGn(handle);
	TRACEARGn(pItem);

	return S_FALSE;
}

HRESULT CResultsPaneView::OnDblClick(CResultsPaneItem* pItem)
{
	TRACEX(_T("CResultsPaneView::OnDblClick\n"));
	TRACEARGn(pItem);

	return S_FALSE;
}

HRESULT CResultsPaneView::OnDelete(CResultsPaneItem* pItem)
{
	TRACEX(_T("CResultsPaneView::OnDelete\n"));
	TRACEARGn(pItem);

	RemoveItem(pItem);

	return S_OK;
}

HRESULT CResultsPaneView::OnGetResultViewType(CString& sViewType,long& lViewOptions)
{
	TRACEX(_T("CResultsPaneView::OnGetResultViewType\n"));
	TRACEARGs(sViewType);
	TRACEARGn(lViewOptions);

	return S_OK;
}

HRESULT CResultsPaneView::OnMinimized(BOOL bMinimized)
{
	TRACEX(_T("CResultsPaneView::OnMinimized\n"));
	TRACEARGn(bMinimized);

	return S_OK;
}

HRESULT CResultsPaneView::OnPropertyChange(LPARAM lParam)
{
	TRACEX(_T("CResultsPaneView::OnPropertyChange\n"));
	TRACEARGn(lParam);

	return S_OK;
}

HRESULT CResultsPaneView::OnQueryPagesFor(CResultsPaneItem* pItem)
{
	TRACEX(_T("CResultsPaneView::OnQueryPagesFor\n"));
	TRACEARGn(pItem);

	return S_OK;
}

HRESULT CResultsPaneView::OnRefresh()
{
	TRACEX(_T("CResultsPaneView::OnRefresh\n"));

	return S_OK;
}

HRESULT CResultsPaneView::OnRename(CResultsPaneItem* pItem, const CString& sNewName)
{
	TRACEX(_T("CResultsPaneView::OnRename\n"));
	TRACEARGn(pItem);

	return S_OK;
}

HRESULT CResultsPaneView::OnRestoreView(MMC_RESTORE_VIEW* pRestoreView, BOOL* pbHandled)
{
	TRACEX(_T("CResultsPaneView::OnRestoreView\n"));
	TRACEARGn(pRestoreView);
	TRACEARGn(pbHandled);

	return S_OK;
}

HRESULT CResultsPaneView::OnSelect(CResultsPane* pPane, CResultsPaneItem* pItem, BOOL bSelected)
{
	TRACEX(_T("CResultsPaneView::OnSelect\n"));
	TRACEARGn(pPane);
	TRACEARGn(pItem);
	TRACEARGn(bSelected);

	return S_OK;
}

HRESULT CResultsPaneView::OnShow(CResultsPane* pPane, BOOL bSelecting, HSCOPEITEM hScopeItem)
{
	TRACEX(_T("CResultsPaneView::OnShow\n"));
	TRACEARGn(pPane);
	TRACEARGn(bSelecting);
	TRACEARGn(hScopeItem);

	if( ! GfxCheckObjPtr(pPane,CResultsPane) )
	{
		TRACE(_T("FAILED : pPane is not a valid pointer.\n"));
		return E_FAIL;
	}

	HRESULT hr = S_OK;

  if( bSelecting )
  {
    // add all the columns to the header control
    for( int i=0; i < GetColumnCount(); i++ )
    {
      CListViewColumn* pColumn = GetColumn(i);
			if( pColumn )
			{
				if( ! pColumn->InsertColumn(pPane,i) )
				{
					TRACE(_T("FAILED : CListViewColumn::InsertColumn failed.\n"));
				}
			}
    }

    // insert all the results pane items
    for( i=0; i < GetItemCount(); i++ )
    {
			CResultsPaneItem* pItem = GetItem(i);			
			if( pItem )
			{
				if( ! pItem->InsertItem(pPane,i,true) )
				{
					TRACE(_T("FAILED : CResultsPaneItem::InsertItem failed.\n"));
				}
			}
    }
  }
  else
  {
/*    // remember all the column sizes
    for( int i=0; i < GetColumnCount(); i++ )
    {
			CListViewColumn* pColumn = GetColumn(i);
			if( pColumn )
			{
				pColumn->SaveWidth(pPane,i);
			}
    }

		LPRESULTDATA lpResultData = pPane->GetResultDataPtr();
		if( ! GfxCheckPtr(lpResultData,IResultData) )
		{
			return E_FAIL;
		}

		// remember all the positions of the items
		for( i = 0; i < GetItemCount(); i++ )
		{
			CResultsPaneItem* pItem = NULL;
			RESULTDATAITEM rdi;
			ZeroMemory(&rdi,sizeof(rdi));
			rdi.mask = RDI_INDEX | RDI_PARAM;
			rdi.nIndex = i;
			hr = lpResultData->GetItem(&rdi);
			pItem = (CResultsPaneItem*)rdi.lParam;
			m_ResultItems.SetAt(i,pItem);
		}

		lpResultData->Release();
*/  }

  return hr;
}

HRESULT CResultsPaneView::OnViewChange(CResultsPaneItem* pItem, LONG lArg, LONG lHintParam)
{
	TRACEX(_T("CResultsPaneView::OnViewChange\n"));
	TRACEARGn(pItem);
	TRACEARGn(lArg);
	TRACEARGn(lHintParam);

	return S_OK;
}


void CResultsPaneView::OnFinalRelease()
{
	// When the last reference for an automation object is released
	// OnFinalRelease is called.  The base class will automatically
	// deletes the object.  Add additional cleanup required for your
	// object before calling the base class.

	CCmdTarget::OnFinalRelease();
}


BEGIN_MESSAGE_MAP(CResultsPaneView, CCmdTarget)
	//{{AFX_MSG_MAP(CResultsPaneView)
		// NOTE - the ClassWizard will add and remove mapping macros here.
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

BEGIN_DISPATCH_MAP(CResultsPaneView, CCmdTarget)
	//{{AFX_DISPATCH_MAP(CResultsPaneView)
		// NOTE - the ClassWizard will add and remove mapping macros here.
	//}}AFX_DISPATCH_MAP
END_DISPATCH_MAP()

// Note: we add support for IID_IResultsPaneView to support typesafe binding
//  from VBA.  This IID must match the GUID that is attached to the 
//  dispinterface in the .ODL file.

// {7D4A6864-9056-11D2-BD45-0000F87A3912}
static const IID IID_IResultsPaneView =
{ 0x7d4a6864, 0x9056, 0x11d2, { 0xbd, 0x45, 0x0, 0x0, 0xf8, 0x7a, 0x39, 0x12 } };

BEGIN_INTERFACE_MAP(CResultsPaneView, CCmdTarget)
	INTERFACE_PART(CResultsPaneView, IID_IResultsPaneView, Dispatch)
END_INTERFACE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CResultsPaneView message handlers